locomotivecms_mounter_pull_19 1.5.4

data/lib/locomotive/mounter/models/site.rb

@@ -0,0 +1,28 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class Site < Base
+
+        ## fields ##
+        field :name
+        field :locales
+        field :subdomain
+        field :domains
+        field :seo_title,         localized: true
+        field :meta_keywords,     localized: true
+        field :meta_description,  localized: true
+        field :robots_txt
+        field :timezone
+
+        ## methods ##
+
+        def to_s
+          self.name
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/snippet.rb

@@ -0,0 +1,55 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class Snippet < Base
+
+        ## fields ##
+        field :name
+        field :slug
+
+        field :template, localized: true
+
+        ## methods ##
+
+        # Return the Liquid template based on the template_filepath property
+        # of the snippet. If the template is HAML, then a pre-rendering to Liquid is done.
+        #
+        # @return [ String ] The liquid template
+        #
+        def source
+          @source ||= {}
+
+          source = if self.template.respond_to?(:source)
+            # liquid or haml file
+            self.template.source
+          else
+            # simple string
+            self.template
+          end
+
+          @source[Locomotive::Mounter.locale] = source
+        end
+
+        # Return the params used for the API.
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params
+          params = self.filter_attributes %w(name slug)
+
+          # raw_template
+          params[:template] = self.source rescue nil
+
+          params
+        end
+
+        def to_s
+          self.name
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/theme_asset.rb

@@ -0,0 +1,148 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ThemeAsset < Base
+
+        PRECOMPILED_CSS_TYPES     = %w(sass scss less)
+
+        PRECOMPILED_JS_TYPES      = %w(coffee)
+
+        PRECOMPILED_FILE_TYPES    = PRECOMPILED_CSS_TYPES + PRECOMPILED_JS_TYPES
+
+        CSS_JS_SHORT_PATH_REGEXP  = /^(javascripts|stylesheets|fonts)\/(.*)$/
+
+        ## fields ##
+        field :folder
+
+        ## other accessors ##
+        attr_accessor :filepath, :uri, :size
+
+        ## methods ##
+
+        # Name of the file without any precompiled extensions (.sass, .scss, ...etc)
+        #
+        # @return [ String ] Name of the file
+        #
+        def filename
+          return @filename if @filename
+
+          if self.uri
+            @filename = File.basename(self.uri.path)
+          else
+            regexps   = PRECOMPILED_FILE_TYPES.map { |ext| "\.#{ext}" }.join('|')
+
+            @filename = File.basename(self.filepath).gsub(/#{regexps}/, '')
+          end
+        end
+
+        # Return the virtual path of the asset
+        #
+        # @return [ String ] The virtual path of the asset
+        #
+        def path
+          File.join(self.folder, self.filename)
+        end
+
+        # Return the path without the leading javascripts, stylesheets, fonts
+        # font. This is needed by Sprockets.
+        # Only relevant for javascripts / stylesshets files.
+        #
+        # @return [ String ] The path of the asset without the first folder
+        #
+        def short_path
+          self.path =~ /^(javascripts|stylesheets|fonts)\/(.*)$/
+          $2
+        end
+
+        # Return the mime type of the file based on the Mime::Types lib.
+        #
+        # @return [ String ] The mime type of the file or nil if unknown.
+        #
+        def mime_type
+          type = MIME::Types.type_for(self.filename)
+          type.empty? ? nil : type.first
+        end
+
+        # Is the asset a stylesheet ?
+        #
+        # @return [ Boolean ] True if the filename ends with .css
+        #
+        def stylesheet?
+          File.extname(self.filename) == '.css'
+        end
+
+        # Is the asset a javascript ?
+        #
+        # @return [ Boolean ] True if the filename ends with .js
+        #
+        def javascript?
+          File.extname(self.filename) == '.js'
+        end
+
+        def stylesheet_or_javascript?
+          self.stylesheet? || self.javascript?
+        end
+
+        # Give the priority of the asset depending of its type.
+        # Javascripts and stylesheets are low priority.
+        #
+        # @return [ Integer ] The priority (0 -> high, 100 -> lower)
+        #
+        def priority
+          self.stylesheet_or_javascript? ? 100 : 0
+        end
+
+        # Tell if the asset can be precompiled. For instance, less, sass, scss and
+        # coffeescript assets have to be precompiled.
+        #
+        # @return [ Boolean ] True if it has to be precompiled
+        #
+        def precompiled?
+          @extname ||= File.extname(self.filepath)[1..-1]
+          PRECOMPILED_FILE_TYPES.include?(@extname)
+        end
+
+        # Content of the asset. Pre-compile it if needed.
+        #
+        # @return [ String ] The content of the asset
+        #
+        def content
+          return @raw if @raw
+
+          if self.uri
+            @raw = HTTParty.get(self.uri.to_s).body
+          # elsif self.precompiled?
+            # template = Tilt.new(self.filepath)
+            # @raw = template.render
+          else
+            @raw = File.read(self.filepath)
+          end
+        end
+
+        # Get a fresh version of the content of the asset. Pre-compile it if needed.
+        #
+        # @return [ String ] The content of the asset
+        #
+        def content!
+          @raw = nil # force to reload it
+          self.content
+        end
+
+        # Return the params used for the API.
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params
+          { folder: self.folder }
+        end
+
+        def to_s
+          self.path
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/translation.rb

@@ -0,0 +1,28 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class Translation < Base
+
+        ## fields ##
+        field :key
+        field :values
+
+        ## methods ##
+
+        def get(locale)
+          self.values[locale.to_s]
+        end
+
+        def to_params
+          { key: self.key, values: self.values }
+        end
+
+        def to_s
+          "Translation #{self.key} (#{self.values.keys.join(', ')})"
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/mounting_point.rb

@@ -0,0 +1,65 @@
+module Locomotive
+  module Mounter
+
+    class MountingPoint
+
+      attr_accessor :resources, :root_page, :path
+
+      # attr_reader   :sprockets
+
+      # Initializes Sprockets once the path is set
+      def path= dir
+        @path = dir
+
+        # @sprockets = Locomotive::Mounter::Extensions::Sprockets.environment
+        # %w(fonts stylesheets javascripts).each do |name|
+        #   @sprockets.append_path File.join(dir, 'public', name)
+        # end
+      end
+
+      # Return all the locales defined by the site related to that mounting point.
+      #
+      # @return [ Array ] The list of the locales
+      #
+      def locales
+        self.site.locales || []
+      end
+
+      # Return the default locale which is the first locale defined for a site.
+      # If none, then use the current I18n locale.
+      #
+      # @return [ Symbol ] The default locale
+      #
+      def default_locale
+        (self.locales.first || Locomotive::Mounter.locale).to_sym
+      end
+
+      # Register a resource (site, pages, content types, ...etc) and its elements.
+      # It makes sure that all the elements get a pointer to that mounting point.
+      # The elements can be either an array, hash or even a single object (ex: site).
+      # For instance, for a page, it will be a hash whose key is the fullpath.
+      #
+      # @param [ Symbol ] name Name of the resource
+      # @param [ Object ] elements Element(s) related to the resource
+      #
+      def register_resource(name, elements)
+        self.resources ||= {}
+
+        (elements.respond_to?(:values) ? elements.values : [*elements]).each do |element|
+          element.mounting_point = self
+        end
+
+        self.resources[name.to_sym] = elements
+      end
+
+      def method_missing(name, *args, &block)
+        (self.resources || {})[name.to_sym] || super
+      end
+
+      def inspect
+        "[MountingPoint] #{(self.resources || {}).keys.inspect}"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+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
+
+        def self.teardown
+          @@instance = nil
+        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
+            credentials = self.parameters.select { |k, _| %w(uri email password api_key).include?(k.to_s) }
+            self.uri    = credentials[:uri]
+
+            begin
+              Locomotive::Mounter::EngineApi.set_token(credentials)
+            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
+
+          # Return the uri with the scheme (http:// or https://)
+          #
+          # @return [ String ] The uri starting by http:// or https://
+          #
+          def uri_with_scheme
+            self.uri =~ /^http/ ? self.uri : "http://#{self.uri}"
+          end
+
+          # Return the base uri with the scheme ((http:// or https://)) and without the path (/locomotive/...)
+          #
+          # @return [ String ] The uri starting by http:// or https:// and without the path
+          #
+          def base_uri_with_scheme
+            self.uri_with_scheme.to_s[/^https?:\/\/[^\/]+/] || self.uri_with_scheme
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class Base
+
+          include Locomotive::Mounter::Utils::Output
+
+          attr_accessor :runner, :items
+
+          delegate :uri, :uri_with_scheme, :base_uri_with_scheme, to: :runner
+          delegate :locales, to: :mounting_point
+
+          def initialize(runner)
+            self.runner  = runner
+            self.items   = {}
+          end
+
+          def mounting_point
+            self.runner.mounting_point
+          end
+
+          def read
+            self.output_title(:pulling)
+          end
+
+          def get(resource_name, locale = nil, dont_filter_attributes = false)
+            attribute_names = dont_filter_attributes ? nil : self.safe_attributes
+
+            begin
+              Locomotive::Mounter::EngineApi.fetch(resource_name, {}, locale, attribute_names)
+            rescue ApiReadException => e
+              raise ReaderException.new(e.message)
+            end
+          end
+
+          # Build a new content asset from an url and a folder and add it
+          # to the global list of the content assets.
+          #
+          # @param [ String ] url The url of the content asset.
+          # @param [ String ] folder The folder of the content asset (optional).
+          #
+          # @return [ String ] The local path (not absolute) of the content asset.
+          #
+          def add_content_asset(url, folder = nil)
+            content_assets = self.mounting_point.resources[:content_assets]
+
+            if (url =~ /^https?:\/\//).nil?
+              url = URI.join(self.uri_with_scheme, url)
+            else
+              url = URI(url)
+            end
+
+            asset = Locomotive::Mounter::Models::ContentAsset.new(uri: url, folder: folder)
+
+            content_assets[url.path] = asset
+
+            asset.local_filepath
+          end
+
+        end
+
+      end
+    end
+  end
+end