locomotivecms_mounter_pull_19 1.5.4

data/lib/locomotive/mounter/config.rb

@@ -0,0 +1,21 @@
+module Locomotive
+  module Mounter
+
+    class Config < Hash
+
+      def self.instance
+        @@instance ||= self.new
+      end
+
+      def self.register(attributes)
+        self.instance.merge!(attributes)
+      end
+
+      def self.[](key)
+        self.instance[key]
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/mounter/engine_api.rb

@@ -0,0 +1,205 @@
+require 'uri'
+
+module Locomotive
+  module Mounter
+
+    class EngineApi
+
+      include HTTMultiParty
+
+      format :json
+
+      # Get a new token from the Engine API and set it for
+      # this class. It raises an exception if the operation fails.
+      # Example of the base uri: locomotivecms.com, nocoffee.fr.
+      #
+      # @param [ Hash / Array ] *args A hash or parameters in that order: uri, email, password or uri, api_key
+      #
+      # @return [ String ] The new token
+      #
+      def self.set_token(*args)
+        _credentials = self.credentials(args)
+
+        uri = URI _credentials.delete(:uri)
+        self.base_uri uri.to_s
+        self.basic_auth uri.user, uri.password if uri.userinfo
+
+        response = post('/tokens.json', body: _credentials) #{ email: email, password: password })
+
+        if response.code < 400
+          self.default_params auth_token: response['token']
+          response['token']
+        elsif response.code == 404 # ssl option missing
+          raise WrongCredentials.new("#{uri}/tokens.json does not respond. Perhaps, the ssl option is missing in your config/deploy.yml file")
+        else
+          raise WrongCredentials.new("#{response['message']} (#{response.code})")
+        end
+      end
+
+      # Read a resource or a list of resources from the API
+      # Raise an exception if something went wrong.
+      #
+      # @param [ String ] resource_name The path to the resource (usually, the resource name)
+      # @param [ Hash ] query If we want to filter the results
+      # @param [ String ] locale The locale for the request
+      # @param [ Array ] attribute_names The attributes we want to keep in the response
+      #
+      def self.fetch(resource_name, query = {}, locale = nil, attribute_names = nil)
+        params = { query: query || {} }
+        params[:query][:locale] = locale if locale
+
+        url       = "/#{resource_name}.json"
+        response  = self.get(url, params)
+        data      = response.parsed_response
+
+        if response.success?
+          object_or_list = self.keep_attributes(data, attribute_names)
+
+          if response.headers['x-total-pages']
+            PaginatedCollection.new(url, params, attribute_names).tap do |collection|
+              collection.list           = object_or_list
+              collection.total_pages    = response.headers['x-total-pages'].to_i
+              collection.total_entries  = response.headers['x-total-entries'].to_i
+            end
+          else
+            object_or_list
+          end
+        else
+          raise ApiReadException.new(data['error'])
+        end
+      end
+
+      # Create a resource from the API.
+      # Raise an exception if something went wrong.
+      #
+      # @param [ String ] resource_name The path to the resource (usually, the resource name)
+      # @param [ Hash ] attributes The attributes of the resource
+      # @param [ String ] locale The locale for the request
+      # @param [ Array ] attribute_names The attributes we want to keep in the response
+      #
+      # @return [ Object] The response of the API
+      #
+      def self.create(resource_name, attributes, locale = nil, attribute_names = nil)
+        params    = self.build_create_or_params(resource_name, attributes, locale)
+        response  = self.post("/#{resource_name}.json", params)
+        data      = response.parsed_response
+
+        if response.success?
+          self.keep_attributes(data, attribute_names)
+        else
+          raise ApiWriteException.new(data)
+        end
+      end
+
+      # Update a resource from the API.
+      # Raise an exception if something went wrong.
+      #
+      # @param [ String ] resource_name The path to the resource (usually, the resource name)
+      # @param [ String ] id The unique identifier of the resource
+      # @param [ Hash ] attributes The attributes of the resource
+      # @param [ String ] locale The locale for the request
+      # @param [ Array ] attribute_names The attributes we want to keep in the response
+      #
+      # @return [ Object] The response of the API
+      #
+      def self.update(resource_name, id, attributes, locale = nil, attribute_names = nil)
+        params    = self.build_create_or_params(resource_name, attributes, locale)
+        response  = self.put("/#{resource_name}/#{id}.json", params)
+        data      = response.parsed_response
+
+        if response.success?
+          self.keep_attributes(data, attribute_names)
+        else
+          raise ApiWriteException.new(data)
+        end
+      end
+
+      def self.teardown
+        Locomotive::Mounter::EngineApi.default_options[:base_uri] = nil
+        Locomotive::Mounter::EngineApi.default_options[:base_auth] = nil
+        Locomotive::Mounter::EngineApi.default_options[:default_params] = {}
+      end
+
+      protected
+
+      def self.credentials(args)
+        if args.first.is_a?(Hash)
+          args.first
+        elsif args.size == 3
+          # uri, email, password
+          { uri: args[0], email: args[1], password: args[2] }
+        elsif args.size == 2
+          # uri, api_key
+          { uri: args[0], api_key: args[1] }
+        else
+          {}
+        end
+      end
+
+      def self.build_create_or_params(resource_name, attributes, locale)
+        name = resource_name.to_s.split('/').last.singularize
+
+        params = { query: { name => attributes } }
+        params[:query][:locale] = locale if locale
+
+        params
+      end
+
+      def self.keep_attributes(data, attribute_names)
+        return data if attribute_names.blank?
+
+        case data
+        when Hash then data.to_hash.delete_if { |k, _| !attribute_names.include?(k) }
+        when Array
+          data.map do |row|
+            row.delete_if { |k, _| !attribute_names.include?(k) }
+          end
+        else
+          data
+        end
+      end
+
+    end
+
+    class PaginatedCollection < Struct.new(:url, :params, :attribute_names)
+
+      attr_accessor :list, :total_pages, :total_entries
+
+      alias :size :total_entries
+
+      def each(&block)
+        if self.total_pages == 1 && self.list
+          self.list.each(&block)
+        else
+          self.paginated_each(&block)
+        end
+      end
+
+      def paginated_each(&block)
+        loop do
+          self.params[:query][:page] = self.page
+
+          response  = Locomotive::Mounter::EngineApi.get(self.url, self.params)
+          data      = response.parsed_response
+
+          if response.success?
+            self.list = Locomotive::Mounter::EngineApi.send(:keep_attributes, data, self.attribute_names)
+            self.list.each(&block)
+          else
+            raise ApiReadException.new(data['error'])
+          end
+
+          break if self.page >= self.total_pages
+
+          @page += 1
+        end
+      end
+
+      def page
+        @page ||= 1
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/mounter/exceptions.rb

@@ -0,0 +1,44 @@
+module Locomotive
+  module Mounter
+
+    class DefaultException < ::Exception
+
+      def initialize(message = nil)
+        Locomotive::Mounter.logger.error message
+        super
+      end
+
+    end
+
+    class ReaderException < DefaultException
+    end
+
+    class WriterException < DefaultException
+    end
+
+    class ImplementationIsMissingException < DefaultException
+    end
+
+    class FieldDoesNotExistException < DefaultException
+    end
+
+    class UnknownContentTypeException < DefaultException
+    end
+
+    class DuplicateContentEntryException < DefaultException
+    end
+
+    class UnknownTemplateException < DefaultException
+    end
+
+    class WrongCredentials < DefaultException
+    end
+
+    class ApiReadException < DefaultException
+    end
+
+    class ApiWriteException < DefaultException
+    end
+
+  end
+end

data/lib/locomotive/mounter/extensions/compass.rb

@@ -0,0 +1,38 @@
+module Locomotive
+  module Mounter
+    module Extensions
+
+      module Compass
+
+        # Configure Compass for the current site.
+        # [DEPRECATED] we use sprockets-sass now
+        #
+        # @param [ String ] site_path The root directory of the site
+        #
+        def self.configure(site_path)
+          ::Compass.configuration do |config|
+            config.project_path     = File.join(site_path, 'public')
+            config.http_path        = '/'
+            config.css_dir          = '../tmp/stylesheets'
+            config.sass_dir         = 'stylesheets'
+            config.fonts_dir        = 'fonts'
+            config.images_dir       = 'images'
+            config.javascripts_dir  = 'javascripts'
+            config.project_type     = :stand_alone
+            config.output_style     = :nested
+            config.line_comments    = false
+          end
+        end
+
+        # # Return the Compass options
+        # #
+        # # @return [ Hash ] The Compass options
+        # def self.options
+        #   ::Compass.configuration.to_sass_engine_options
+        # end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/extensions/httmultiparty.rb

@@ -0,0 +1,22 @@
+# Patch for https://github.com/jwagener/httmultiparty/issues/11
+
+module HTTMultiParty
+  module ClassMethods
+
+    private
+
+      def perform_request(http_method, path, options, &block) #:nodoc:
+        options = default_options.dup.merge(options)
+
+        # FIXME: default_params are not handled for some unknown reasons, so move them to the body instead
+        if http_method == MultipartPost || http_method == MultipartPut
+          default_params = options.delete(:default_params)
+          options[:body].merge!(default_params) if options[:body] && default_params
+        end
+
+        process_cookies(options)
+        HTTParty::Request.new(http_method, path, options).perform(&block)
+      end
+
+  end
+end

data/lib/locomotive/mounter/extensions/sprockets.rb

@@ -0,0 +1,46 @@
+require 'yui/compressor'
+
+module Locomotive
+  module Mounter
+    module Extensions
+
+      module Sprockets
+
+        @@env = @@path = nil
+
+        # Build a Sprocket environment for the current site.
+        # This method returns an unique environment for each call
+        # unless the site_path changed.
+        #
+        # @param [ String ] site_path The root directory of the site
+        # @param [ Boolean ] minify Minify the js and css assets (default: false)
+        #
+        def self.environment(site_path, minify = false)
+          return @@env if @@env && @@path == site_path
+
+          @@path  = site_path
+          @@env   = ::Sprockets::Environment.new.tap do |env|
+            if minify && is_java_installed?
+              # minify javascripts and stylesheets
+              env.js_compressor  = YUI::JavaScriptCompressor.new
+              env.css_compressor = YUI::CssCompressor.new
+            else
+              message = "[Important] YUICompressor requires java to be installed. The JAVA_HOME variable should also be set.\n"
+              Locomotive::Mounter.logger.warn message.colorize(color: :red)
+            end
+
+            %w(fonts stylesheets javascripts).each do |name|
+              env.append_path File.join(site_path, 'public', name)
+            end
+          end
+        end
+
+        def self.is_java_installed?
+          `which java` != '' && (!ENV['JAVA_HOME'].blank? && File.exists?(ENV['JAVA_HOME']))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/extensions/tilt/css.rb

@@ -0,0 +1,31 @@
+module Tilt
+
+  # Sass with Compass features
+  class SassWithCompassTemplate < SassTemplate
+
+    private
+
+    def sass_options
+      super.merge(::Compass.configuration.to_sass_engine_options)
+    end
+
+  end
+
+  Tilt.register 'sass', SassWithCompassTemplate
+  Tilt.prefer SassWithCompassTemplate
+
+  # Scss with Compass features
+  class ScssWithCompassTemplate < ScssTemplate
+
+    private
+
+    def sass_options
+      super.merge(::Compass.configuration.to_sass_engine_options)
+    end
+
+  end
+
+  Tilt.register 'scss', ScssWithCompassTemplate
+  Tilt.prefer ScssWithCompassTemplate
+
+end

data/lib/locomotive/mounter/fields.rb

@@ -0,0 +1,254 @@
+module Locomotive
+  module Mounter
+
+    module Fields
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveSupport::Callbacks
+
+        define_callbacks :initialize
+
+        class << self; attr_accessor :_fields end
+
+        attr_accessor :_locales
+      end
+
+      # Default constructor
+      #
+      # @param [ Hash ] attributes The new attributes
+      #
+      def initialize(attributes = {})
+        run_callbacks :initialize do
+          _attributes = attributes.symbolize_keys
+
+          # set default values
+          self.class._fields.each do |name, options|
+            next if !options.key?(:default) || _attributes.key?(name)
+
+            _attributes[name] = options[:default]
+          end
+
+          # set default translation
+          self.add_locale(Locomotive::Mounter.locale)
+
+          self.write_attributes(_attributes)
+        end
+      end
+
+      # Set or replace the attributes of the current instance by the ones
+      # passed as parameter.
+      # It raises an exception if one of the keys is not included in the list of fields.
+      #
+      # @param [ Hash ] attributes The new attributes
+      #
+      def write_attributes(attributes)
+        return if attributes.blank?
+
+        attributes.each do |name, value|
+          unless self.class._fields.key?(name.to_sym) || self.respond_to?(:"#{name}=")
+            next if name.to_s == 'id'
+            raise FieldDoesNotExistException.new "[#{self.class.inspect}] setting an unknown attribute '#{name}' with the value '#{value.inspect}'"
+          end
+
+          if self.localized_field?(name) && value.is_a?(Hash)
+            self.send(:"#{name}_translations=", value)
+          else
+            self.send(:"#{name}=", value)
+          end
+        end
+      end
+
+      alias :attributes= :write_attributes
+
+      # Return the fields with their values
+      #
+      # @return [ Hash ] The attributes
+      #
+      def attributes
+        {}.tap do |_attributes|
+          self.class._fields.each do |name, options|
+            _attributes[name] = self.send(name.to_sym)
+          end
+        end
+      end
+
+      def [](name)
+        self.attributes[name.to_sym]
+      end
+
+      # Return the fields with their values and their translations
+      #
+      # @return [ Hash ] The attributes
+      #
+      def attributes_with_translations
+        {}.tap do |_attributes|
+          self.class._fields.each do |name, options|
+            next if options[:association]
+
+            if options[:localized]
+              value = self.send(:"#{name}_translations")
+
+              value = value.values.first if value.size == 1
+
+              value = nil if value.respond_to?(:empty?) && value.empty?
+
+              _attributes[name] = value
+            else
+              _attributes[name] = self.send(name.to_sym)
+            end
+          end
+        end
+      end
+
+      # Check if the field specified by the argument is localized
+      #
+      # @param [ String ] name Name of the field
+      #
+      # @return [ Boolean ] True if the field is localized
+      #
+      def localized_field?(name)
+        method_name = :"#{name}_localized?"
+        self.respond_to?(method_name) && self.send(method_name)
+      end
+
+      # List all the translations done on that model
+      #
+      # @return [ List ] List of locales
+      #
+      def translated_in
+        self._locales.map(&:to_sym)
+      end
+
+      # Tell if the object has been translated in the locale
+      # passed in parameter.
+      #
+      # @param [ String/Symbol ] locale
+      #
+      # @return [ Boolean ] True if one of the fields has been translated.
+      #
+      def translated_in?(locale)
+        self.translated_in.include?(locale.to_sym)
+      end
+
+      # Return a Hash of all the non blank attributes of the object.
+      # It also performs a couple of modifications: stringify keys and
+      # convert Symbol to String.
+      #
+      # @param [ Boolean ] translation Flag (by default true) to get the translations too.
+      #
+      # @return [ Hash ] The non blank attributes
+      #
+      def to_hash(translations = true)
+        hash = translations ? self.attributes_with_translations : self.attributes
+
+        hash.delete_if { |k, v| (!v.is_a?(FalseClass) && v.blank?) }
+
+        hash.each { |k, v| hash[k] = v.to_s if v.is_a?(Symbol) }
+
+        hash.deep_stringify_keys
+      end
+
+      # Provide a better output of the default to_yaml method
+      #
+      # @return [ String ] The YAML version of the object
+      #
+      def to_yaml
+        # get the attributes with their translations and get rid of all the symbols
+        object = self.to_hash
+
+        object.each do |key, value|
+          if value.is_a?(Array)
+            object[key] = if value.first.is_a?(String)
+              StyledYAML.inline(value) # inline array
+            else
+              value.map(&:to_hash)
+            end
+          end
+        end
+
+        StyledYAML.dump object
+      end
+
+      protected
+
+      def getter(name, options = {})
+        value = self.instance_variable_get(:"@#{name}")
+        if options[:localized]
+          value = (value || {})[Locomotive::Mounter.locale]
+        end
+        value
+      end
+
+      def setter(name, value, options = {})
+        if options[:localized]
+          # keep track of the current locale
+          self.add_locale(Locomotive::Mounter.locale)
+
+          translations = self.instance_variable_get(:"@#{name}") || {}
+          translations[Locomotive::Mounter.locale] = value
+          value = translations
+        end
+
+        if options[:type] == :array
+          klass = options[:class_name].constantize
+          value = value.map { |object| object.is_a?(Hash) ? klass.new(object) : object }
+        end
+
+        self.instance_variable_set(:"@#{name}", value)
+      end
+
+      def add_locale(locale)
+        self._locales ||= []
+        self._locales << locale.to_sym unless self._locales.include?(locale.to_sym)
+      end
+
+      module ClassMethods
+
+        # Add a field to the current instance. It creates getter/setter methods related to that field.
+        # A field can have translations if the option named localized is set to true.
+        #
+        # @param [ String ] name The name of the field
+        # @param [ Hash ] options The options related to the field.
+        #
+        def field(name, options = {})
+          options = { localized: false }.merge(options)
+
+          @_fields ||= {} # initialize the list of fields if nil
+
+          self._fields[name.to_sym] = options
+
+          class_eval <<-EOV
+            def #{name}
+              self.getter '#{name}', self.class._fields[:#{name}]
+            end
+
+            def #{name}=(value)
+              self.setter '#{name}', value, self.class._fields[:#{name}] #, #{options[:localized]}
+            end
+
+            def #{name}_localized?
+              #{options[:localized]}
+            end
+          EOV
+
+          if options[:localized]
+            class_eval <<-EOV
+              def #{name}_translations
+                @#{name} || {}
+              end
+
+              def #{name}_translations=(translations)
+                translations.each { |locale, value| self.add_locale(locale) }
+                @#{name} = translations.symbolize_keys
+              end
+            EOV
+          end
+        end
+
+      end
+
+    end
+  end
+end