locomotivecms_mounter_pull_19 1.5.4

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

@@ -0,0 +1,36 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        class TranslationsReader < Base
+
+          # Build the list of translations based on the config/translations.yml file
+          #
+          # @return [ Hash ] Hash whose the key is the translation key
+          #
+          def read
+            config_path = File.join(self.runner.path, 'config', 'translations.yml')
+
+            {}.tap do |translations|
+              if File.exists?(config_path)
+                (self.read_yaml(config_path) || []).each do |translation|
+                  key, values = translation
+
+                  entry = Locomotive::Mounter::Models::Translation.new({
+                    key:    key,
+                    values: values
+                  })
+
+                  translations[key] = entry
+                end
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Locomotive
+  module Mounter
+    module Reader
+
+      class Runner
+
+        attr_accessor :kind, :parameters, :mounting_point
+
+        def initialize(kind)
+          self.kind = kind
+
+           # avoid to load all the ruby files at the startup, only when we need it
+           base_dir = File.join(File.dirname(__FILE__), kind.to_s)
+           require File.join(base_dir, 'base.rb')
+           Dir[File.join(base_dir, '*.rb')].each { |lib| require lib }
+        end
+
+        # Read the content of a site (pages, snippets, ...etc) and create the corresponding mounting point.
+        #
+        # @param [ Hash ] parameters The parameters.
+        #
+        # @return [ Object ] The mounting point object storing all the information about the site
+        #
+        def run!(parameters = {})
+          self.parameters = parameters.symbolize_keys
+
+          self.prepare
+
+          self.build_mounting_point
+        end
+
+        # Reload with the same origin parameters a part of a site from a list of
+        # resources each described by a simple name (site, pages, ...etc) taken from
+        # the corresponding reader class name.
+        #
+        # @param [ Array/ String ] list An array of resource(s) or just the resource
+        #
+        def reload(*list)
+          Locomotive::Mounter.with_locale(self.mounting_point.default_locale) do
+            [*list].flatten.each do |name|
+              reader_name = "#{name.to_s.camelize}Reader"
+
+              reader = self.readers.detect do |_reader|
+                _reader.name.demodulize == reader_name
+              end
+
+              if reader
+                self.mounting_point.register_resource(name, reader.new(self).read)
+              end
+            end
+          end
+        end
+
+        # Before building the mounting point.
+        # Can be defined by reader runners
+        def prepare
+        end
+
+        # Ordered list of atomic readers
+        #
+        # @return [ Array ] List of classes
+        #
+        def readers
+          raise Locomotive::Mounter::ImplementationIsMissingException.new('readers are missing')
+        end
+
+        protected
+
+        def build_mounting_point
+          Locomotive::Mounter::MountingPoint.new.tap do |mounting_point|
+            self.mounting_point = mounting_point
+
+            self.readers.each do |reader|
+              name = reader.name.gsub(/(Reader)$/, '').demodulize.underscore
+
+              self.mounting_point.register_resource(name, reader.new(self).read)
+            end
+
+            if self.respond_to?(:path)
+              self.mounting_point.path = self.path
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/utils/hash.rb

@@ -0,0 +1,31 @@
+unless Hash.instance_methods.include?(:deep_stringify_keys)
+  class Hash
+
+    # Return a new hash with all keys converted to strings.
+    # This includes the keys from the root hash and from all
+    # nested hashes.
+    def deep_stringify_keys
+      result = {}
+      each do |key, value|
+        result[key.to_s] = value.is_a?(Hash) ? value.deep_stringify_keys : value
+      end
+      result
+    end
+
+  end
+end
+
+unless Hash.instance_methods.include?(:deep_symbolize_keys)
+  class Hash
+
+    # See http://iain.nl/writing-yaml-files
+    def deep_symbolize_keys
+      {}.tap do |new_hash|
+        self.each do |key, value|
+          new_hash.merge!(key.to_sym => (value.is_a?(Hash) ? value.deep_symbolize_keys : value))
+        end
+      end
+    end
+
+  end
+end

data/lib/locomotive/mounter/utils/output.rb

@@ -0,0 +1,124 @@
+module Locomotive
+  module Mounter
+    module Utils
+      module Output
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          @@buffer_enabled  = false
+          @@buffer_log      = ''
+
+        end
+
+        protected
+
+        # Print the the title for each kind of resource.
+        #
+        def output_title(action = :pushing)
+          msg = "* #{action.to_s.capitalize} #{self.class.name.gsub(/(Writer|Reader)$/, '').demodulize}"
+          self.log msg.colorize(background: :white, color: :black) + "\n"
+        end
+
+        # Print the current locale.
+        #
+        def output_locale
+          locale = Locomotive::Mounter.locale.to_s
+          self.log "  #{locale.colorize(background: :blue, color: :white)}\n"
+        end
+
+        def truncate(string, length = 50, separator = '[...]')
+          if string.length > length
+            string[0..(length - separator.length)] + separator
+          else
+            string
+          end
+        end
+
+        # Print the message about the creation / update of a resource.
+        #
+        # @param [ Object ] resource The resource (Site, Page, ...etc).
+        #
+        def output_resource_op(resource)
+          self.log self.resource_message(resource)
+        end
+
+        # Print the message about the creation / update of a resource.
+        #
+        # @param [ Object ] resource The resource (Site, Page, ...etc).
+        # @param [ Symbol ] status :success, :error, :skipped
+        # @param [ String ] errors The error messages
+        #
+        def output_resource_op_status(resource, status = :success, errors = nil)
+          status_label = case status
+          when :success         then 'done'.colorize(color: :green)
+          when :error           then 'error'.colorize(color: :red)
+          when :skipped         then 'skipped'.colorize(color: :magenta)
+          when :same            then 'same'.colorize(color: :magenta)
+          when :not_translated  then 'not translated (itself or parent)'.colorize(color: :yellow)
+          end
+
+          spaces = '.' * (80 - self.resource_message(resource).size)
+          self.log "#{spaces}[#{status_label}]\n"
+
+          if errors && status == :error
+            self.log "#{errors.colorize(color: :red)}\n"
+          end
+        end
+
+        # Return the message about the creation / update of a resource.
+        #
+        # @param [ Object ] resource The resource (Site, Page, ...etc).
+        #
+        # @return [ String ] The message
+        #
+        def resource_message(resource)
+          op_label = resource.persisted? ? 'updating': 'creating'
+          "    #{op_label} #{truncate(resource.to_s)}"
+        end
+
+        # Log a message to the console or the logger depending on the options
+        # of the runner. Info is the log level if case the logger has been chosen.
+        #
+        # @param [ String ] message The message to log.
+        #
+        def log(message)
+          # puts "buffer ? #{@@buffer_enabled.inspect}"
+          if @@buffer_enabled
+            @@buffer_log << message
+          else
+            if self.runner.parameters[:console]
+              print message
+            else
+              Mounter.logger.info message #.gsub(/\n$/, '')
+            end
+          end
+        end
+
+        # Put in a buffer the logs generated when executing the block.
+        # It means that they will not output unless the flush_log_buffer
+        # method is called.
+        #
+        # @return [ Object ] Thee value returned by the call of the block
+        #
+        def buffer_log(&block)
+          @@buffer_log = ''
+          @@buffer_enabled = true
+          if block_given?
+            block.call.tap { @@buffer_enabled = false }
+          end
+        end
+
+        # Flush the logs put in a buffer.
+        #
+        def flush_log_buffer
+          @@buffer_enabled = false
+          self.log(@@buffer_log)
+          @@buffer_log = ''
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/utils/string.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+## String
+
+class String #:nodoc
+
+  def permalink(underscore = false)
+    # if the slug includes one "_" at least, we consider that the "_" is used instead of "-".
+    _permalink = if !self.index('_').nil?
+      self.to_url(replace_whitespace_with: '_')
+    else
+      self.to_url
+    end
+
+    underscore ? _permalink.underscore : _permalink
+  end
+
+  def permalink!(underscore = false)
+    replace(self.permalink(underscore))
+  end
+
+  alias :parameterize! :permalink!
+
+end
+
+
+# class String #:nodoc
+
+#   def permalink(underscore = false)
+#     permalink = self.to_ascii.parameterize
+#     underscore ? permalink.underscore : permalink
+#   end
+
+#   def permalink!(underscore = false)
+#     replace(self.permalink(underscore))
+#   end
+
+#   alias :parameterize! :permalink!
+
+# end

data/lib/locomotive/mounter/utils/yaml.rb

@@ -0,0 +1,125 @@
+# http://stackoverflow.com/questions/9556546/is-there-a-way-to-tell-psych-in-ruby-to-using-inline-mode
+# https://gist.github.com/2023978
+
+require 'psych'
+require 'stringio'
+
+# Public: A Psych extension to enable choosing output styles for specific
+# objects.
+#
+# Thanks to Tenderlove for help in <http://stackoverflow.com/q/9640277/11687>
+#
+# Examples
+#
+#   data = {
+#     response: { body: StyledYAML.literal(json_string), status: 200 },
+#     person: StyledYAML.inline({ 'name' => 'Stevie', 'age' => 12 }),
+#     array: StyledYAML.inline(%w[ apples bananas oranges ])
+#   }
+#
+#   StyledYAML.dump data, $stdout
+#
+module StyledYAML
+  # Tag strings to be output using literal style
+  def self.literal obj
+    obj.extend LiteralScalar
+    return obj
+  end
+
+  # http://www.yaml.org/spec/1.2/spec.html#id2795688
+  module LiteralScalar
+    def yaml_style() Psych::Nodes::Scalar::LITERAL end
+  end
+
+  # Tag Hashes or Arrays to be output all on one line
+  def self.inline obj
+    case obj
+    when Hash  then obj.extend FlowMapping
+    when Array then obj.extend FlowSequence
+    else
+      warn "#{self}: unrecognized type to inline (#{obj.class.name})"
+    end
+    return obj
+  end
+
+  # http://www.yaml.org/spec/1.2/spec.html#id2790832
+  module FlowMapping
+    def yaml_style() Psych::Nodes::Mapping::FLOW end
+  end
+
+  # http://www.yaml.org/spec/1.2/spec.html#id2790320
+  module FlowSequence
+    def yaml_style() Psych::Nodes::Sequence::FLOW end
+  end
+
+  # Custom tree builder class to recognize scalars tagged with `yaml_style`
+  class TreeBuilder < Psych::TreeBuilder
+    attr_writer :next_sequence_or_mapping_style
+
+    def initialize(*args)
+      super
+      @next_sequence_or_mapping_style = nil
+    end
+
+    def next_sequence_or_mapping_style default_style
+      style = @next_sequence_or_mapping_style || default_style
+      @next_sequence_or_mapping_style = nil
+      style
+    end
+
+    def scalar value, anchor, tag, plain, quoted, style
+      if style_any?(style) and value.respond_to?(:yaml_style) and style = value.yaml_style
+        if style_literal? style
+          plain = false
+          quoted = true
+        end
+      end
+      super
+    end
+
+    def style_any?(style) Psych::Nodes::Scalar::ANY == style end
+
+    def style_literal?(style) Psych::Nodes::Scalar::LITERAL == style end
+
+    %w[sequence mapping].each do |type|
+      class_eval <<-RUBY
+        def start_#{type}(anchor, tag, implicit, style)
+          style = next_sequence_or_mapping_style(style)
+          super
+        end
+      RUBY
+    end
+  end
+
+  # Custom tree class to handle Hashes and Arrays tagged with `yaml_style`
+  class YAMLTree < Psych::Visitors::YAMLTree
+    %w[Hash Array Psych_Set Psych_Omap].each do |klass|
+      class_eval <<-RUBY
+        def visit_#{klass} o
+          if o.respond_to? :yaml_style
+            @emitter.next_sequence_or_mapping_style = o.yaml_style
+          end
+          super
+        end
+      RUBY
+    end
+  end
+
+  # A Psych.dump alternative that uses the custom TreeBuilder
+  def self.dump obj, io = nil, options = {}
+    real_io = io || StringIO.new(''.encode('utf-8'))
+    visitor = YAMLTree.new(options, TreeBuilder.new)
+    visitor << obj
+    ast = visitor.tree
+
+    begin
+      ast.yaml real_io
+    rescue
+      # The `yaml` method was introduced in later versions, so fall back to
+      # constructing a visitor
+      Psych::Visitors::Emitter.new(real_io).accept ast
+    end
+
+    io ? io : real_io.string
+  end
+end