locomotivecms_mounter 1.0.0.alpha1

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

@@ -0,0 +1,65 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        class Base
+
+          attr_accessor :runner, :items
+
+          delegate :default_locale, :locales, to: :mounting_point
+
+          def initialize(runner)
+            self.runner  = runner
+            self.items   = {}
+          end
+
+          def mounting_point
+            self.runner.mounting_point
+          end
+
+          protected
+
+          # Return the locale of a file based on its extension.
+          #
+          # Ex:
+          #   about_us/john_doe.fr.liquid.haml => 'fr'
+          #   about_us/john_doe.liquid.haml => 'en' (default locale)
+          #
+          # @param [ String ] filepath The path to the file
+          #
+          # @return [ String ] The locale (ex: fr, en, ...etc) or nil if it has no information about the locale
+          #
+          def filepath_locale(filepath)
+            locale = File.basename(filepath).split('.')[1]
+
+            if locale.nil?
+              # no locale, use the default one
+              self.default_locale
+            elsif self.locales.include?(locale)
+              # the locale is registered
+              locale
+            elsif locale.size == 2
+              # unregistered locale
+              nil
+            else
+              self.default_locale
+            end
+          end
+
+          # Open a YAML file and returns the content of the file
+          #
+          # @param [ String ] filepath The path to the file
+          #
+          # @return [ Object ] The content of the file
+          #
+          def read_yaml(filepath)
+            YAML::load(File.open(filepath).read.force_encoding('utf-8'))
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        class ContentAssetsReader < Base
+
+          # Build the list of contents assets
+          #
+          # @return [ Array ] The list of content assets
+          #
+          def read
+            self.items = [] # prefer an array over a hash
+
+            self.fetch_from_pages
+
+            self.fetch_from_content_entries
+
+            self.items
+          end
+
+          protected
+
+          # Fetch the files from the template of all the pages
+          #
+          def fetch_from_pages
+            self.mounting_point.pages.values.each do |page|
+              page.translated_in.each do |locale|
+                Locomotive::Mounter.with_locale(locale) do
+                  unless page.template.blank?
+                    self.add_assets_from_string(page.source)
+                  end
+                end
+              end
+            end
+          end
+
+          # Fetch the files from the content entries
+          #
+          def fetch_from_content_entries
+            self.mounting_point.content_entries.values.each do |content_entry|
+              content_entry.translated_in.each do |locale|
+                Locomotive::Mounter.with_locale(locale) do
+                  # get the string, text, file fields...
+                  content_entry.content_type.fields.each do |field|
+                    case field.type.to_sym
+                    when :string, :text
+                      self.add_assets_from_string(content_entry.dynamic_getter(field.name))
+                    when :file
+                      self.add_assets_from_string(content_entry.dynamic_getter(field.name)['url'])
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Parse the string passed in parameter in order to
+          # look for content assets. If found, then add them.
+          #
+          # @param [ String ] source The string to parse
+          #
+          def add_assets_from_string(source)
+            return if source.blank?
+
+            source.to_s.match(/\/samples\/.*\.[a-zA-Z0-9]+/) do |match|
+              filepath  = File.join(self.root_dir, match.to_s)
+              folder    = File.dirname(match.to_s)
+              self.items << Locomotive::Mounter::Models::ContentAsset.new(filepath: filepath, folder: folder)
+            end
+          end
+
+          # 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
+
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        class ContentEntriesReader < Base
+
+          # 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_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)
+
+              content_type = self.get_content_type(File.basename(filepath, '.yml'))
+
+              content_type.entries.try(:clear)
+
+              attributes.each_with_index do |_attributes, index|
+                self.add(content_type, _attributes, index)
+              end
+            end
+          end
+
+          # Get the content type identified by the slug from the mounting point.
+          # Raise an UnknownContentTypeException exception if such a content type
+          # does not exist.
+          #
+          # @param [ String ] slug The slug of the content type
+          #
+          # @return [ Object ] The instance of the content type
+          #
+          def get_content_type(slug)
+            self.mounting_point.content_types[slug.to_s].tap do |content_type|
+              if content_type.nil?
+                raise UnknownContentTypeException.new("unknow content type #{slug.inspect}")
+              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
+          # @param [ Integer ] position The position of the entry in the list
+          #
+          def add(content_type, attributes, position)
+            if attributes.is_a?(String)
+              label, _attributes = attributes, {}
+            else
+              label, _attributes = attributes.keys.first, attributes.values.first
+            end
+
+            # check if the label_field is localized or not
+            label_field_name = content_type.label_field_name
+
+            if content_type.label_field.localized && _attributes.key?(label_field_name) && _attributes[label_field_name].is_a?(Hash)
+              _attributes[label_field_name].merge!(Locomotive::Mounter.locale => label).symbolize_keys!
+            else
+              _attributes[label_field_name] = label
+            end
+
+            _attributes[:_position] = position
+
+            entry = content_type.build_entry(_attributes)
+
+            # puts "entry._slug = #{entry._slug.inspect}"
+            # entry.main_locale = Locomotive::Mounter.locale
+            # puts entry.to_hash.inspect
+            # puts entry.dynamic_attributes.inspect
+            # puts entry.send(:sync_translations)
+
+            key = File.join(content_type.slug, entry._slug)
+
+            self.items[key] = entry
+          end
+
+          # Return the directory where all the entries
+          # of the content types are stored.
+          #
+          # @return [ String ] The content entries root directory
+          #
+          def root_dir
+            File.join(self.runner.path, 'data')
+          end
+
+        end
+
+      end
+    end
+  end
+end

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,206 @@
+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
+            folders = []
+
+            Dir.glob(File.join(self.root_dir, '**/*')).each do |filepath|
+              fullpath = self.filepath_to_fullpath(filepath)
+
+              folders.push(fullpath) && next if File.directory?(filepath)
+
+              next unless filepath =~ /\.(#{Locomotive::Mounter::TEMPLATE_EXTENSIONS.join('|')})$/
+
+              page = self.add(fullpath)
+
+              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
+            end
+
+            folders.each do |fullpath|
+              next if self.pages.key?(fullpath)
+              self.add(fullpath)
+            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)
+              attributes[:title]    = File.basename(fullpath).humanize
+              attributes[:fullpath] = fullpath
+
+              self.pages[fullpath]  = Locomotive::Mounter::Models::Page.new(attributes)
+            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 = Tilt.new(filepath)
+
+            if template.respond_to?(:attributes)
+              return if template.attributes.blank?
+
+              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})"
+
+            (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,24 @@
+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)
+         end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+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.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 = Tilt.new(filepath)
+              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: Tilt.new(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
+          end
+
+        end
+
+      end
+    end
+  end
+end