locomotivecms_mounter_pull_19 1.5.4

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

@@ -0,0 +1,42 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class SiteReader < Base
+
+          def read
+            super
+
+            # 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
+
+              # set the time zone for the next Time operations (UTC by default)
+              Time.zone = ActiveSupport::TimeZone.new(site.timezone || 'UTC')
+            end
+          end
+
+          def safe_attributes
+            %w(name locales seo_title meta_keywords meta_description domains subdomain timezone created_at updated_at)
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+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
+            super
+
+            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 created_at updated_at)
+          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
+            super
+
+            self.items = self.get(:theme_assets).map do |attributes|
+              url = attributes.delete('url')
+              url.gsub!(/^\/\//, "https://")
+
+              attributes['uri'] = URI(url =~ /^https?:\/\// ? url : "#{self.base_uri_with_scheme}#{url}")
+
+              Locomotive::Mounter::Models::ThemeAsset.new(attributes)
+            end
+          end
+
+          protected
+
+          def safe_attributes
+            %w(_id folder url created_at updated_at)
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+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
+            super
+
+            self.items = get(:translations).each_with_object({}) do |attributes,hash|
+              hash[attributes['key']] = Locomotive::Mounter::Models::Translation.new(attributes)
+            end
+          end
+
+          protected
+          def safe_attributes
+            %w[_id key values created_at updated_at]
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Locomotive
+  module Mounter
+    module Reader
+     module FileSystem
+
+       # Build a singleton instance of the Runner class.
+       #
+       # @return [ Object ] A singleton instance of the Runner class
+       #
+       def self.instance
+         @@instance ||= Runner.new(:file_system)
+       end
+
+       class Runner < Locomotive::Mounter::Reader::Runner
+
+         attr_accessor :path
+
+         # Compass is required
+         def prepare
+           self.path = parameters.delete(:path)
+
+           if self.path.blank? || !File.exists?(self.path)
+             raise Locomotive::Mounter::ReaderException.new('path is required and must exist')
+           end
+
+           # TODO: Steam should deal with that
+           Locomotive::Mounter::Extensions::Compass.configure(self.path)
+         end
+
+         # Ordered list of atomic readers
+         #
+         # @return [ Array ] List of classes
+         #
+         def readers
+           [SiteReader, ContentTypesReader, PagesReader, SnippetsReader, ContentEntriesReader, ContentAssetsReader, ThemeAssetsReader, TranslationsReader]
+         end
+
+       end
+
+      end
+    end
+  end
+end

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,90 @@
+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.template.raw_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|
+                    value = content_entry.dynamic_getter(field.name)
+
+                    case field.type.to_sym
+                    when :string, :text
+                      self.add_assets_from_string(value)
+                    when :file
+                      self.add_assets_from_string(value['url']) if value
+                    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[source] = 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,97 @@
+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 unless attributes == false
+            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
+
+            # build the content entry
+            entry = content_type.build_entry(_attributes)
+
+            # and store it
+            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