locomotivecms_mounter 1.0.0.alpha1

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,40 @@
+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
+      #
+      # @return [ String ] The new token
+      #
+      def self.set_token(*args)
+        uri, email, password = (if args.first.is_a?(Hash)
+          [args.first[:uri], args.first[:email], args.first[:password]]
+        else
+          [*args]
+        end)
+
+        self.base_uri uri
+
+        response = post('/tokens.json', body: { email: email, password: password })
+
+        if response.code < 400
+          self.default_params auth_token: response['token']
+          response['token']
+        else
+          raise WrongCredentials.new("#{response['message']} (#{response.code})")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/mounter/exceptions.rb

@@ -0,0 +1,38 @@
+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
+
+  end
+end

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

@@ -0,0 +1,36 @@
+module Locomotive
+  module Mounter
+    module Extensions
+
+      module Compass
+
+        # Configure Compass for the current site
+        #
+        # @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.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/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/extensions/tilt/haml.rb

@@ -0,0 +1,27 @@
+module Tilt
+
+  # YAML Front-matters for HAML templates
+  class YamlFrontMattersHamlTemplate < HamlTemplate
+
+    # Attributes from YAML Front-matters header
+    attr_reader :attributes
+
+    def need_for_prerendering?
+      true
+    end
+
+    def prepare
+      if data =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)(.*)/m
+        @attributes = YAML.load($1)
+        @data = $3
+      end
+      @data = @data.force_encoding('utf-8')
+      super
+    end
+
+  end
+
+  Tilt.register 'haml', YamlFrontMattersHamlTemplate
+  Tilt.prefer YamlFrontMattersHamlTemplate
+
+end

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

@@ -0,0 +1,23 @@
+module Tilt
+
+  # YAML Front-matters for Liquid templates
+  class YamlFrontMattersLiquidTemplate < Template
+
+    # Attributes from YAML Front-matters header
+    attr_reader :attributes
+
+    def prepare
+      if data =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)(.*)/m
+        @attributes = YAML.load($1)
+        @data = $3
+      end
+      @data = @data.force_encoding('utf-8')
+      # Note: do not call 'super' because we are going to use a different parse mechanism
+    end
+
+  end
+
+  Tilt.register 'liquid', YamlFrontMattersLiquidTemplate
+  Tilt.prefer YamlFrontMattersLiquidTemplate
+
+end

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

@@ -0,0 +1,11 @@
+module Tilt
+
+  class Template
+
+    def need_for_prerendering?
+      false
+    end
+
+  end
+
+end

data/lib/locomotive/mounter/fields.rb

@@ -0,0 +1,250 @@
+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}=")
+            raise FieldDoesNotExistException.new "[#{self.class.inspect}] setting an unknown attribute '#{name}' with the value '#{value.inspect}'"
+          end
+
+          if self.localized?(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
+
+      # 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.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?(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.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 || {})[Locomotive::Mounter.locale]
+        else
+          value
+        end
+      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

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

@@ -0,0 +1,41 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class Base
+
+        include Locomotive::Mounter::Fields
+
+        attr_accessor :_id, :mounting_point
+
+        ## methods ##
+
+        def initialize(attributes = {})
+          self.mounting_point = attributes.delete(:mounting_point)
+          super
+        end
+
+        def persisted?
+        	!self._id.blank?
+        end
+
+        protected
+
+        # Take a list of field names and return a hash with
+        # their values only if they are not nil.
+        #
+        # @param [ Array ] fields List of field names (string)
+        #
+        # @return [ Hash ] A hash with symbolize keys
+        #
+        def filter_attributes(fields)
+          self.attributes.clone.delete_if do |k, v|
+            !fields.include?(k.to_s) || (!v.is_a?(FalseClass) && v.blank?)
+          end.deep_symbolize_keys
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ContentAsset < Base
+
+        ## fields ##
+        field :source
+
+        ## other accessors ##
+        attr_accessor :folder, :filepath, :uri
+
+        ## methods ##
+
+        # Name of the file
+        #
+        # @return [ String ] Name of the file
+        #
+        def filename
+          return @filename if @filename
+
+          if self.uri
+            @filename = File.basename(self.uri.path)
+          else
+            @filename = File.basename(self.filepath)
+          end
+        end
+
+        # Content of the asset.
+        #
+        # @return [ String ] The content of the asset
+        #
+        def content
+          return @raw if @raw
+
+          if self.uri
+            @raw = Net::HTTP.get(self.uri)
+          else
+            @raw = File.read(self.filepath)
+          end
+        end
+
+        def size
+          if self.uri
+            Net::HTTP.get(self.uri).body.size
+          else
+            File.size(self.filepath)
+          end
+        end
+
+        # Return true if the uri or the file exists.
+        #
+        # @return [ Boolean ] True if it exists
+        #
+        def exists?
+          self.size
+          true
+        rescue
+          false
+        end
+
+        def local_filepath
+          File.join('/', self.folder, self.filename)
+        end
+
+        # Return the params used for the API.
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params
+          return {} if self.uri
+
+          { source: File.new(self.filepath) }
+        end
+
+        def to_s
+          self.uri ? self.uri.path : self.filename
+        end
+
+      end
+
+    end
+  end
+end