locomotivecms_mounter 1.0.0.alpha1

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

@@ -0,0 +1,78 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        class ThemeAssetsReader < Base
+
+          # Build the list of theme assets from the public folder with eager loading.
+          #
+          # @return [ Array ] The cached list of theme assets
+          #
+          def read
+            ThemeAssetsArray.new(self.root_dir)
+          end
+
+          protected
+
+          # 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
+
+      class ThemeAssetsArray
+
+        attr_accessor :root_dir
+
+        def initialize(root_dir)
+          self.root_dir = root_dir
+        end
+
+        def list
+          return @list unless @list.nil?
+
+          @list = [].tap do |list|
+            Dir.glob(File.join(self.root_dir, '**/*')).each do |file|
+              next if self.exclude?(file)
+
+              folder = File.dirname(file.gsub(self.root_dir, ''))
+
+              asset = Locomotive::Mounter::Models::ThemeAsset.new(folder: folder, filepath: file)
+
+              list << asset
+            end
+          end
+        end
+
+        # Tell if the file has to be excluded from the array
+        # of theme assets. It does not have to be a folder
+        # or be in the samples folder or owns a name starting with
+        # the underscore character.
+        #
+        # @param [ String ] file The full path to the file
+        #
+        # @return [ Boolean ] True if it does not have to be included in the list.
+        #
+        def exclude?(file)
+          File.directory?(file) ||
+          file.starts_with?(File.join(self.root_dir, 'samples')) ||
+          File.basename(file).starts_with?('_')
+        end
+
+        # This class acts a proxy of an array
+        def method_missing(name, *args, &block)
+          self.list.send(name.to_sym, *args, &block)
+        end
+
+      end
+    end
+  end
+end

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/file_system.rb

@@ -0,0 +1,42 @@
+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
+
+           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/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/string.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+## String
+
+class String #:nodoc
+
+  def permalink
+    self.to_ascii.parameterize('-')
+  end
+
+  def permalink!
+    replace(self.permalink)
+  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

data/lib/locomotive/mounter/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+module Locomotive
+  module Mounter #:nodoc
+
+    VERSION = '1.0.0.alpha1'
+
+  end
+end