locomotivecms_wagon 2.0.0.pre.alpha.3 → 2.0.0.pre.beta.1

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_base_command.rb

@@ -0,0 +1,83 @@
+require_relative './concerns/assets_concern'
+
+module Locomotive::Wagon
+
+  class PullBaseCommand < Struct.new(:api_client, :current_site, :path)
+
+    include Locomotive::Wagon::AssetsConcern
+
+    def self.pull(api_client, current_site, path)
+      new(api_client, current_site, path).pull
+    end
+
+    def pull
+      instrument do
+        instrument :start
+        self._pull_with_timezone
+        instrument :done
+      end
+    end
+
+    def _pull_with_timezone
+      Time.use_zone(current_site.try(:timezone)) do
+        _pull
+      end
+    end
+
+    def instrument(action = nil, payload = {}, &block)
+      name = [instrument_base_name, [*action]].flatten.compact.join('.')
+      ActiveSupport::Notifications.instrument(name, { name: resource_name }.merge(payload), &block)
+    end
+
+    def dump(element, options = {})
+      if element.is_a?(Hash)
+        StyledYAML.dump(element.dup.tap do |attributes|
+          [*options[:inline]].each do |name|
+            attributes[name] = StyledYAML.inline(attributes[name])
+          end
+        end)
+      else
+        element.to_yaml
+      end.gsub(/\A---\n/, '')
+    end
+
+    def clean_attributes(attributes)
+      # remove nil or empty values
+      attributes.delete_if { |_, v| v.nil? || v == '' || (v.is_a?(Hash) && v.empty?) }
+    end
+
+    def write_to_file(filepath, content = nil, mode = 'w+', &block)
+      _filepath = File.join(path, filepath)
+
+      folder = File.dirname(_filepath)
+      FileUtils.mkdir_p(folder) unless File.exists?(folder)
+
+      File.open(_filepath, mode) do |file|
+        file.write(content ? content : yield)
+      end
+    end
+
+    def reset_file(filepath)
+      _filepath = File.join(path, filepath)
+      FileUtils.rm(_filepath) if File.exists?(_filepath)
+    end
+
+    def instrument_base_name
+      'wagon.pull'
+    end
+
+    def resource_name
+      self.class.name[/::Pull(\w+)Command$/, 1].underscore
+    end
+
+    def default_locale
+      current_site.locales.first
+    end
+
+    def locales
+      current_site.locales
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_content_assets_command.rb

@@ -0,0 +1,24 @@
+module Locomotive::Wagon
+
+  class PullContentAssetsCommand < PullBaseCommand
+
+    def _pull
+      api_client.content_assets.all.each do |asset|
+        write_content_asset(asset)
+      end
+    end
+
+    def write_content_asset(asset)
+      binary = get_asset_binary(asset.url)
+      write_to_file(content_asset_filepath(asset), binary)
+    end
+
+    private
+
+    def content_asset_filepath(asset)
+      File.join('public', 'samples', 'all', asset.content_type_text, asset.filename)
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_content_entries_command.rb

@@ -0,0 +1,94 @@
+module Locomotive::Wagon
+
+  class PullContentEntriesCommand < PullBaseCommand
+
+    def _pull
+      fetch_content_types do |content_type|
+        # delete the previous file
+        reset_file(content_entry_filepath(content_type))
+
+        fetch_content_entries(content_type) do |entries|
+          # entries is a list of max 10 elements (pagination)
+          write_content_entries(content_type, entries)
+        end
+      end
+    end
+
+    def write_content_entries(content_type, entries)
+      _entries = entries.map do |entry|
+        yaml_attributes(content_type, entry)
+      end
+
+      write_to_file(content_entry_filepath(content_type), dump(_entries), 'a')
+    end
+
+    private
+
+    def yaml_attributes(content_type, entry)
+      fields            = %w(_slug) + content_type.fields.map { |f| f['name'] } + %w(seo_title meta_description meta_keywords)
+      localized_fields  = (content_type.attributes['localized_names'] || []) + %w(_slug seo_title meta_description meta_keywords)
+      fields_with_urls  = content_type.attributes['urls_names']
+
+      attributes = {}
+
+      fields.each do |name|
+        attributes[name] = if localized_fields.include?(name) && locales.size > 1 && !content_type.attributes['localized_names'].empty?
+          clean_attributes({}.tap do |translations|
+            locales.each { |l| translations[l] = value_of(content_type, entry, l, name) }
+          end)
+        else
+          value_of(content_type, entry, default_locale, name)
+        end
+      end
+
+      { entry[default_locale].attributes[content_type.label_field_name] => clean_attributes(attributes) }
+    end
+
+    def fetch_content_types(&block)
+      api_client.content_types.all.each do |content_type|
+        content_type.attributes['localized_names'] = content_type.fields.map { |f| f['localized'] ? f['name'] : nil }.compact
+        content_type.attributes['urls_names'] = content_type.fields.map { |f| %w(file text).include?(f['type']) ? f['name'] : nil }.compact
+        yield(content_type)
+      end
+    end
+
+    def fetch_content_entries(content_type, &block)
+      page = 1
+      while page do
+        entries, _next_page = {}, nil
+
+        locales.each do |locale|
+          next if locale != default_locale && content_type.localized_names.empty?
+
+          (_entries = api_client.content_entries(content_type).all(nil, { page: page }, locale)).each do |entry|
+            (entries[entry._id] ||= {})[locale] = entry
+          end
+
+          _next_page = _entries._next_page if _next_page.nil?
+        end
+
+        yield(entries.values)
+
+        page = _next_page
+      end
+    end
+
+    def value_of(content_type, entry, locale, name)
+      if value = entry[locale].attributes[name]
+        if content_type.attributes['urls_names'].try(:include?, name)
+          replace_asset_urls(value)
+        else
+          value
+        end
+      else
+        nil
+      end
+    end
+
+    def content_entry_filepath(content_type)
+      File.join('data', "#{content_type.slug}.yml")
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_content_types_command.rb

@@ -0,0 +1,42 @@
+module Locomotive::Wagon
+
+  class PullContentTypesCommand < PullBaseCommand
+
+    def _pull
+      api_client.content_types.all.each do |content_type|
+        write_content_type(content_type)
+      end
+    end
+
+    def write_content_type(content_type)
+      yaml = dump(yaml_attributes(content_type), inline: %w(public_submission_account_emails))
+
+      write_to_file(content_type_filepath(content_type), yaml)
+    end
+
+    private
+
+    def yaml_attributes(content_type)
+      content_type.attributes.slice('name', 'slug', 'description', 'label_field_name', 'order_by', 'order_direction', 'group_by', 'public_submission_enabled', 'public_submission_account_emails', 'display_settings').tap do |attributes|
+        # fields
+        attributes['fields'] = content_type.fields.map { |f| field_yaml_attributes(f) }
+
+        clean_attributes(attributes)
+      end
+    end
+
+    def field_yaml_attributes(field)
+      attributes = field.slice('label', 'type', 'required', 'hint', 'localized', 'select_options', 'class_name', 'inverse_of', 'ui_enabled')
+
+      clean_attributes(attributes)
+
+      { field['name'] => attributes }
+    end
+
+    def content_type_filepath(content_type)
+      File.join('app', 'content_types', "#{content_type.slug}.yml")
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_pages_command.rb

@@ -0,0 +1,54 @@
+module Locomotive::Wagon
+
+  class PullPagesCommand < PullBaseCommand
+
+    attr_reader :fullpaths
+
+    def _pull
+      @fullpaths = {}
+
+      locales.each do |locale|
+        api_client.pages.all(locale).each do |page|
+          fullpaths[page._id] = page.fullpath if locale == default_locale
+          write_page(page, locale)
+        end
+      end
+    end
+
+    def write_page(page, locale = nil)
+      write_to_file(page_filepath(page, locale)) do
+<<-EOF
+#{yaml_attributes(page, locale)}---
+#{replace_asset_urls(page.template)}
+EOF
+      end
+    end
+
+    private
+
+    def yaml_attributes(page, locale)
+      attributes = page.attributes.slice('title', 'slug', 'handle', 'position', 'listed', 'published', 'redirect_url', 'is_layout', 'content_type', 'seo_title', 'meta_description', 'meta_keywords')
+
+      if locale != default_locale
+        attributes.delete_if { |k, _| %w(handle position listed published is_layout content_type).include?(k) }
+      end
+
+      # editable elements
+      attributes['editable_elements'] = page.editable_elements.inject({}) do |hash, el|
+        hash["#{el['block']}/#{el['slug']}"] = replace_asset_urls(el['content']) if el['content']
+        hash
+      end
+
+      clean_attributes(attributes)
+
+      attributes.to_yaml
+    end
+
+    def page_filepath(page, locale)
+      fullpath = locale == default_locale ? page.fullpath : "#{fullpaths[page._id]}.#{locale}"
+      File.join('app', 'views', 'pages', fullpath + '.liquid')
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_site_command.rb

@@ -0,0 +1,55 @@
+module Locomotive::Wagon
+
+  class PullSiteCommand < PullBaseCommand
+
+    def _pull
+      attributes = current_site.attributes.slice('name', 'locales', 'domains', 'timezone', 'seo_title', 'meta_keywords', 'meta_description', 'picture_thumbnail_url')
+
+      locales.each_with_index do |locale, index|
+        if index == 0
+          transform_in_default_locale(attributes, locale)
+        else
+          add_other_locale(attributes, locale)
+        end
+      end if locales.size > 1
+
+      write_icon(attributes.delete('picture_thumbnail_url'))
+
+      write_to_file(File.join('config', 'site.yml')) do
+        dump(attributes, inline: %w(locales domains))
+      end
+    end
+
+    private
+
+    def write_icon(url)
+      return if url.blank?
+
+      unless url =~ /\Ahttp:\/\//
+        base = api_client.uri.dup.tap { |u| u.path = '' }.to_s
+        url = URI.join(base, url).to_s
+      end
+
+      File.open(File.join(path, 'icon.png'), 'wb') do |file|
+        file.write Faraday.get(url).body
+      end
+    end
+
+    def localized_attributes(&block)
+      %w(seo_title meta_keywords meta_description).each do |name|
+        yield(name)
+      end
+    end
+
+    def transform_in_default_locale(attributes, locale)
+      localized_attributes { |k| attributes[k] = { locale => attributes[k] } }
+    end
+
+    def add_other_locale(attributes, locale)
+      _site = api_client.current_site.get(locale)
+      localized_attributes { |k| attributes[k][locale] = _site.attributes[k] }
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_snippets_command.rb

@@ -0,0 +1,29 @@
+module Locomotive::Wagon
+
+  class PullSnippetsCommand < PullBaseCommand
+
+    def _pull
+      locales.each do |locale|
+        api_client.snippets.all(locale).each do |snippet|
+          write_snippet(snippet, locale)
+        end
+      end
+    end
+
+    def write_snippet(snippet, locale = nil)
+      if (template = snippet.template).present?
+        _template = replace_asset_urls(template)
+        write_to_file(snippet_filepath(snippet, locale), _template)
+      end
+    end
+
+    private
+
+    def snippet_filepath(snippet, locale)
+      filename = locale == default_locale ? snippet.slug : "#{snippet.slug}.#{locale}"
+      File.join('app', 'views', 'snippets', filename + '.liquid')
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_theme_assets_command.rb

@@ -0,0 +1,29 @@
+module Locomotive::Wagon
+
+  class PullThemeAssetsCommand < PullBaseCommand
+
+    def _pull
+      api_client.theme_assets.all.each do |asset|
+        write_theme_asset(asset)
+      end
+    end
+
+    def write_theme_asset(asset)
+      binary = get_asset_binary(asset.url)
+
+      if %w(javascript stylesheet).include?(asset.content_type)
+        binary = replace_asset_urls(binary)
+      end
+
+      write_to_file(theme_asset_filepath(asset), binary)
+    end
+
+    private
+
+    def theme_asset_filepath(asset)
+      File.join('public', asset.folder, asset.local_path)
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/pull_sub_commands/pull_translations_command.rb

@@ -0,0 +1,24 @@
+module Locomotive::Wagon
+
+  class PullTranslationsCommand < PullBaseCommand
+
+    def _pull
+      translations = api_client.translations.all.inject({}) do |hash, translation|
+        hash[translation.key] = translation.values
+        hash
+      end
+
+      unless translations.empty?
+        write_to_file(translations_filepath, dump(translations))
+      end
+    end
+
+    private
+
+    def translations_filepath
+      File.join('config', 'translations.yml')
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/push_command.rb

@@ -13,7 +13,7 @@ module Locomotive::Wagon
 
   class PushCommand < Struct.new(:env, :path, :options, :shell)
 
-    RESOURCES = %w(content_types content_entries pages snippets theme_assets translations).freeze
+    RESOURCES = %w(site content_types content_entries pages snippets theme_assets translations).freeze
 
     RESOURCES_WITH_CONTENT = %w(content_entries translations).freeze
 

data/lib/locomotive/wagon/commands/push_sub_commands/push_site_command.rb

@@ -0,0 +1,28 @@
+module Locomotive::Wagon
+
+  class PushSiteCommand < PushBaseCommand
+
+    def entities
+      [repositories.site.first]
+    end
+
+    def decorate(entity)
+      IconSiteDecorator.new(entity)
+    end
+
+    def persist(decorated_entity)
+      _attributes = decorated_entity.to_hash
+      if !_attributes.empty? && api_client.current_site.get.attributes[:picture_url].nil?
+        api_client.current_site.update(_attributes)
+      else
+        raise SkipPersistingException.new
+      end
+    end
+
+    def label_for(decorated_entity)
+      decorated_entity.name
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/serve_command.rb

@@ -56,7 +56,7 @@ module Locomotive::Wagon
 
       Locomotive::Steam.configure do |config|
         config.mode         = :test
-        config.adapter      = { name: :filesystem, path: path }
+        config.adapter      = { name: :filesystem, path: File.expand_path(path) }
         config.asset_path   = File.expand_path(File.join(path, 'public'))
 
         if port = options[:live_reload_port]

data/lib/locomotive/wagon/commands/sync_command.rb

@@ -0,0 +1,57 @@
+require 'locomotive/common'
+
+require_relative '../tools/styled_yaml'
+
+require_relative 'loggers/sync_logger'
+
+require_relative_all  'concerns'
+require_relative      'sync_sub_commands/concerns/base_concern'
+
+require_relative      'pull_sub_commands/pull_base_command'
+require_relative_all  'pull_sub_commands'
+require_relative_all  'sync_sub_commands'
+
+module Locomotive::Wagon
+
+  class SyncCommand < Struct.new(:env, :path, :options)
+
+    RESOURCES = %w(pages content_entries translations).freeze
+
+    include ApiConcern
+    include DeployFileConcern
+    include InstrumentationConcern
+
+    def self.sync(env, path, options)
+      self.new(env, path, options).sync
+    end
+
+    def sync
+      SyncLogger.new if options[:verbose]
+
+      api_client = api_site_client(connection_information)
+      site = api_client.current_site.get
+
+      each_resource do |klass|
+        klass.sync(api_client, site, path)
+      end
+    end
+
+    private
+
+    def each_resource
+      RESOURCES.each do |name|
+        next if !options[:resources].blank? && !options[:resources].include?(name)
+
+        klass = "Locomotive::Wagon::Sync#{name.camelcase}Command".constantize
+
+        yield klass
+      end
+    end
+
+    def connection_information
+      read_deploy_settings(self.env, self.path)
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/sync_sub_commands/concerns/base_concern.rb

@@ -0,0 +1,41 @@
+require 'active_support/concern'
+
+module Locomotive::Wagon
+
+  module BaseConcern
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      alias :_sync :_pull
+
+    end
+
+    module ClassMethods
+
+      def sync(api_client, current_site, path)
+        new(api_client, current_site, path).sync
+      end
+
+    end
+
+    def sync
+      instrument do
+        instrument :start
+        self._sync
+        instrument :done
+      end
+    end
+
+    def instrument_base_name
+      'wagon.sync'
+    end
+
+    def resource_name
+      self.class.name[/::Sync(\w+)Command$/, 1].underscore
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/sync_sub_commands/sync_content_entries_command.rb

@@ -0,0 +1,9 @@
+module Locomotive::Wagon
+
+  class SyncContentEntriesCommand < PullContentEntriesCommand
+
+    include Locomotive::Wagon::BaseConcern
+
+  end
+
+end

data/lib/locomotive/wagon/commands/sync_sub_commands/sync_pages_command.rb

@@ -0,0 +1,41 @@
+module Locomotive::Wagon
+
+  class SyncPagesCommand < PullPagesCommand
+
+    include Locomotive::Wagon::BaseConcern
+
+    def write_page(page, locale = nil)
+      if attributes = editable_elements_attributes(page, locale)
+        new_content = replace_editable_elements(page_filepath(page, locale), dump(attributes))
+
+        write_to_file(page_filepath(page, locale), new_content)
+      end
+    end
+
+    private
+
+    def editable_elements_attributes(page, locale)
+      list = page.editable_elements.inject({}) do |hash, el|
+        hash["#{el['block']}/#{el['slug']}"] = replace_asset_urls(el['content']) if el['content']
+        hash
+      end
+
+      list.empty? ? nil : { 'editable_elements' => list }
+    end
+
+    def replace_editable_elements(filepath, replacement)
+      content   = File.read(File.join(path, filepath))
+      existing  = content =~ /\A.*?editable_elements:.*?\n---/m
+
+      content.gsub /\A---(.*?)\n---/m do |s|
+        if existing
+          s.gsub(/editable_elements:\n(.*?)\n(\S)/m) { |_s| "#{replacement}#{$2}" }
+        else
+          s.gsub(/---\Z/) { |_s| "#{replacement}\n---" }
+        end
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/commands/sync_sub_commands/sync_translations_command.rb

@@ -0,0 +1,9 @@
+module Locomotive::Wagon
+
+  class SyncTranslationsCommand < PullTranslationsCommand
+
+    include Locomotive::Wagon::BaseConcern
+
+  end
+
+end

data/lib/locomotive/wagon/decorators/concerns/to_hash_concern.rb

@@ -17,7 +17,7 @@ module Locomotive::Wagon
     end
 
     def prepare_value_for_hash(value)
-      if value.is_a?(Array) && value.first.respond_to?(:__attributes__)
+      if value.is_a?(Array) && value.any? { |v| v.respond_to?(:__attributes__) }
         value.map(&:to_hash)
       elsif value.is_a?(Array) && value.empty?
         nil # reset the array