locomotive_cms 0.0.4 → 1.0.0.beta

data/lib/locomotive/import/assets.rb

@@ -1,24 +1,26 @@
 module Locomotive
   module Import
-    module Assets
+    class Assets < Base
 
-      def self.process(context)
-        site, theme_path = context[:site], context[:theme_path]
+      def process
+        whitelist = self.build_regexps_in_withlist(database['site']['assets']['whitelist']) rescue nil
 
-        whitelist = self.build_regexps_in_withlist(context[:database]['site']['assets']['whitelist']) rescue nil
+        self.log "white list = #{whitelist.inspect}"
 
-        self.add_theme_assets(site, theme_path, whitelist)
+        self.add_theme_assets(whitelist)
 
-        self.add_other_assets(site, theme_path)
+        self.add_other_assets
       end
 
-      def self.add_theme_assets(site, theme_path, whitelist)
+      protected
+
+      def add_theme_assets(whitelist)
         %w(images media fonts javascripts stylesheets).each do |kind|
           Dir[File.join(theme_path, 'public', kind, '**/*')].each do |asset_path|
 
             next if File.directory?(asset_path)
 
-            visible = self.check_against_whitelist(whitelist, asset_path.gsub(File.join(theme_path, 'public'), ''))
+            visible = self.check_against_whitelist(whitelist, asset_path.gsub(File.join(theme_path, 'public'), '').gsub(/^\//, ''))
 
             folder = asset_path.gsub(File.join(theme_path, 'public'), '').gsub(File.basename(asset_path), '').gsub(/^\//, '').gsub(/\/$/, '')
 
@@ -28,27 +30,33 @@ module Locomotive
 
             asset.attributes = { :source => File.open(asset_path), :performing_plain_text => false, :hidden => !visible }
 
-            asset.save!
+            begin
+              asset.save!
+            rescue Exception => e
+              self.log "!ERROR! = #{e.message}, #{asset_path}"
+            end
 
             site.reload
           end
         end
       end
 
-      def self.add_other_assets(site, theme_path)
+      def add_other_assets
         collection = AssetCollection.find_or_create_internal(site)
 
         Dir[File.join(theme_path, 'public', 'samples', '*')].each do |asset_path|
 
           next if File.directory?(asset_path)
 
+          self.log "other asset = #{asset_path}"
+
           name = File.basename(asset_path, File.extname(asset_path)).parameterize('_')
 
           collection.assets.create! :name => name, :source => File.open(asset_path)
         end
       end
 
-      def self.build_regexps_in_withlist(rules)
+      def build_regexps_in_withlist(rules)
         rules.collect do |rule|
           if rule.start_with?('^')
             Regexp.new(rule.gsub('/', '\/'))
@@ -58,7 +66,7 @@ module Locomotive
         end
       end
 
-      def self.check_against_whitelist(whitelist, path)
+      def check_against_whitelist(whitelist, path)
         (whitelist || []).each do |rule|
           case rule
             when Regexp

data/lib/locomotive/import/base.rb

@@ -0,0 +1,46 @@
+module Locomotive
+  module Import
+    class Base
+
+      include Logger
+
+      attr_reader :context, :options
+
+      def initialize(context, options)
+        @context = context
+        @options = options
+        self.log "*** starting to process ***"
+      end
+
+      def self.process(context, options)
+        self.new(context, options).process
+      end
+
+      def process
+        raise 'this method has to be overidden'
+      end
+
+      def log(message)
+        super(message, self.class.name.demodulize.underscore)
+      end
+
+      protected
+
+      def site
+        @context[:site]
+      end
+
+      def database
+        @context[:database]
+      end
+
+      def theme_path
+        @context[:theme_path]
+      end
+
+      def open_sample_asset(url)
+        File.open(File.join(self.theme_path, 'public', url))
+      end
+    end
+  end
+end

data/lib/locomotive/import/content_types.rb

@@ -1,20 +1,16 @@
 module Locomotive
   module Import
-    module ContentTypes
-
-      def self.process(context)
-        site, database = context[:site], context[:database]
-
-        content_types = database['site']['content_types']
+    class ContentTypes < Base
 
+      def process
         return if content_types.nil?
 
         content_types.each do |name, attributes|
-          puts "....content_type = #{attributes['slug']}"
+          self.log "[content_types] slug = #{attributes['slug']}"
 
           content_type = site.content_types.where(:slug => attributes['slug']).first
 
-          content_type ||= self.build_content_type(site, attributes.merge(:name => name))
+          content_type ||= self.build_content_type(attributes.merge(:name => name))
 
           self.add_or_update_fields(content_type, attributes['fields'])
 
@@ -24,21 +20,31 @@ module Locomotive
 
           self.set_group_by_value(content_type)
 
+          if options[:samples] && attributes['contents']
+            self.insert_samples(content_type, attributes['contents'])
+          end
+
           content_type.save!
 
           site.reload
         end
       end
 
-      def self.build_content_type(site, data)
-        attributes = { :order_by => '_position_in_list', :group_by_field_name => data.delete('group_by') }.merge(data)
+      protected
+
+      def content_types
+        database['site']['content_types']
+      end
+
+      def build_content_type(data)
+        attributes = { :group_by_field_name => data.delete('group_by') }.merge(data)
 
         attributes.delete_if { |name, value| %w{fields contents}.include?(name) }
 
         site.content_types.build(attributes)
       end
 
-      def self.add_or_update_fields(content_type, fields)
+      def add_or_update_fields(content_type, fields)
         fields.each_with_index do |data, position|
           name, data = data.keys.first, data.values.first
 
@@ -54,24 +60,54 @@ module Locomotive
         end
       end
 
-      def self.set_highlighted_field_name(content_type)
+      def insert_samples(content_type, contents)
+        contents.each_with_index do |data, position|
+          value, attributes = data.is_a?(Array) ? [data.first, data.last] : [data.keys.first, data.values.first]
+
+          # build with default attributes
+          content = content_type.contents.build(content_type.highlighted_field_name.to_sym => value, :_position_in_list => position)
+
+          attributes.each do |name, value|
+            field = content_type.content_custom_fields.detect { |f| f._alias == name }
+
+            value = (case field.kind.downcase
+            when 'file'     then self.open_sample_asset(value)
+            when 'boolean'  then Boolean.set(value)
+            else
+              value
+            end)
+
+            content.send("#{name}=", value)
+          end
+
+          content.save
+
+          self.log "insert content '#{content.send(content_type.highlighted_field_name.to_sym)}'"
+        end
+      end
+
+      def set_highlighted_field_name(content_type)
         field = content_type.content_custom_fields.detect { |f| f._alias == content_type.highlighted_field_name }
 
         content_type.highlighted_field_name = field._name if field
       end
 
-      def self.set_order_by_value(content_type)
+      def set_order_by_value(content_type)
+        self.log "order by #{content_type.order_by}"
+
         order_by = (case content_type.order_by
         when 'manually', '_position_in_list' then '_position_in_list'
-        when 'date', 'updated_at' then 'updated_at'
+        when 'default', 'created_at' then 'created_at'
         else
           content_type.content_custom_fields.detect { |f| f._alias == content_type.order_by }._name rescue nil
         end)
 
+        self.log "order by (after) #{order_by}"
+
         content_type.order_by = order_by || '_position_in_list'
       end
 
-      def self.set_group_by_value(content_type)
+      def set_group_by_value(content_type)
         return if content_type.group_by_field_name.blank?
 
         field = content_type.content_custom_fields.detect { |f| f._alias == content_type.group_by_field_name }

data/lib/locomotive/import/job.rb

@@ -4,12 +4,21 @@ module Locomotive
   module Import
     class Job
 
-      def initialize(theme_file, site = nil, enabled = {})
-        raise "Theme zipfile not found" unless File.exists?(theme_file)
+      include Logger
 
-        @theme_file = theme_file
+      def initialize(zipfile, site, options = {})
         @site = site
-        @enabled = enabled
+        @options = {
+          :reset    => false,
+          :samples  => false,
+          :enabled  => {}
+        }.merge(options)
+
+        @identifier = self.store_zipfile(zipfile)
+
+        raise "Theme identifier not found" if @identifier.blank?
+
+        @uploader = nil # fix issue with Ruby 1.9.2 and serialization
       end
 
       def before(worker)
@@ -17,7 +26,7 @@ module Locomotive
       end
 
       def perform
-        puts "theme_file = #{@theme_file} / #{@site.present?} / #{@enabled.inspect}"
+        self.log "theme identifier #{@identifier}"
 
         self.unzip!
 
@@ -31,23 +40,96 @@ module Locomotive
           :worker => @worker
         }
 
+        self.reset! if @options[:reset]
+
         %w(site content_types assets asset_collections snippets pages).each do |step|
-          if @enabled[step] != false
-            "Locomotive::Import::#{step.camelize}".constantize.process(context)
+          if @options[:enabled][step] != false
+            "Locomotive::Import::#{step.camelize}".constantize.process(context, @options)
             @worker.update_attributes :step => step if @worker
           else
-            puts "skipping #{step}"
+            self.log "skipping #{step}"
           end
         end
       end
 
+      def success(worker)
+        self.log 'deleting original zip file'
+
+        uploader = self.get_uploader(@site)
+
+        uploader.retrieve_from_store!(@identifier)
+
+        uploader.remove!
+
+        self.log 'deleting working folder'
+
+        FileUtils.rm_rf(themes_folder) rescue nil
+      end
+
+      def self.run!(zipfile, site, options = {})
+        job = self.new(zipfile, site, options)
+
+        if Locomotive.config.delayed_job
+          Delayed::Job.enqueue job, { :site => site, :job_type => 'import' }
+        else
+          job.perform
+        end
+      end
+
       protected
 
+      def themes_folder
+        File.join(Rails.root, 'tmp', 'themes', @site.id.to_s)
+      end
+
+      def prepare_folder
+        FileUtils.rm_rf self.themes_folder if File.exists?(self.themes_folder)
+
+        FileUtils.mkdir_p(self.themes_folder)
+      end
+
+      def store_zipfile(zipfile)
+        return nil if zipfile.blank?
+
+        file = CarrierWave::SanitizedFile.new(zipfile)
+
+        uploader = self.get_uploader(@site)
+
+        begin
+          uploader.store!(file)
+          uploader.identifier
+        rescue CarrierWave::IntegrityError
+          nil
+        end
+      end
+
+      def retrieve_zipfile
+        uploader = self.get_uploader(@site)
+
+        uploader.retrieve_from_store!(@identifier)
+
+        if uploader.file.respond_to?(:url)
+          self.log 'file from remote storage'
+
+          @theme_file = File.join(self.themes_folder, @identifier)
+
+          File.open(@theme_file, 'w') { |f| f.write(uploader.file.read) }
+        else # local filesystem
+          self.log 'file from local storage'
+
+          @theme_file = uploader.path
+        end
+      end
+
       def unzip!
-        Zip::ZipFile.open(@theme_file) do |zipfile|
-          destination_path = File.join(Rails.root, 'tmp', 'themes', @site.id.to_s)
+        self.prepare_folder
+
+        self.retrieve_zipfile
+
+        self.log "unzip #{@theme_file}"
 
-          FileUtils.rm_r destination_path, :force => true
+        Zip::ZipFile.open(@theme_file) do |zipfile|
+          destination_path = self.themes_folder
 
           zipfile.each do |entry|
             next if entry.name =~ /__MACOSX/
@@ -65,7 +147,20 @@ module Locomotive
             zipfile.extract(entry, File.join(destination_path, entry.name))
           end
         end
+      end
 
+      def reset!
+        @site.pages.destroy_all
+        @site.theme_assets.destroy_all
+        @site.content_types.destroy_all
+        @site.asset_collections.destroy_all
+      end
+
+      def get_uploader(site)
+        unless Locomotive.config.delayed_job
+          ThemeUploader.storage = :file
+        end
+        @uploader ||= ThemeUploader.new(site)
       end
 
     end

data/lib/locomotive/import/logger.rb

@@ -0,0 +1,13 @@
+module Locomotive
+  module Import
+    module Logger
+
+      def log(message, domain = '')
+        head = "[import_theme]"
+        head += "[#{domain}]" unless domain.blank?
+        ::Locomotive::Logger.info "\t#{head} #{message}"
+      end
+
+    end
+  end
+end

data/lib/locomotive/import/pages.rb

@@ -1,13 +1,11 @@
 module Locomotive
   module Import
-    module Pages
-
-      def self.process(context)
-        site, pages, theme_path = context[:site], context[:database]['pages'], context[:theme_path]
+    class Pages < Base
 
+      def process
         context[:done] = {} # initialize the hash storing pages already processed
 
-        self.add_index_and_404(context)
+        self.add_index_and_404
 
         Dir[File.join(theme_path, 'templates', '**/*')].each do |template_path|
 
@@ -15,43 +13,50 @@ module Locomotive
 
           next if %w(index 404).include?(fullpath)
 
-          self.add_page(fullpath, context)
+          self.add_page(fullpath)
         end
       end
 
-      def self.add_page(fullpath, context)
-        puts "....adding #{fullpath}"
+      protected
 
+      def add_page(fullpath)
         page = context[:done][fullpath]
 
         return page if page # already added, so skip it
 
-        site, pages, theme_path = context[:site], context[:database]['site']['pages'], context[:theme_path]
-
         template = File.read(File.join(theme_path, 'templates', "#{fullpath}.liquid")) rescue "Unable to find #{fullpath}.liquid"
 
-        self.build_parent_template(template, context)
+        self.replace_images!(template)
 
-        parent = self.find_parent(fullpath, context)
+        self.build_parent_template(template)
 
-        page = site.pages.where(:fullpath => fullpath).first || site.pages.build
+        parent = self.find_parent(fullpath)
 
         attributes = {
           :title        => fullpath.split('/').last.humanize,
           :slug         => fullpath.split('/').last,
           :parent       => parent,
-          :raw_template => template
-        }.merge(pages[fullpath] || {}).symbolize_keys
+          :raw_template => template,
+          :published    => true
+        }.merge(self.pages[fullpath] || {}).symbolize_keys
 
         # templatized ?
         if content_type_slug = attributes.delete(:content_type)
-          attributes[:content_type] = site.content_types.where(:slug => content_type_slug).first
+          fullpath.gsub!(/\/template$/, '/content_type_template')
+          attributes.merge!({
+            :templatized  => true,
+            :content_type => site.content_types.where(:slug => content_type_slug).first
+          })
         end
 
+        page = site.pages.where(:fullpath => fullpath).first || site.pages.build
+
         page.attributes = attributes
 
         page.save!
 
+        self.log "adding #{page.fullpath} / #{page.position}"
+
         site.reload
 
         context[:done][fullpath] = page
@@ -59,7 +64,7 @@ module Locomotive
         page
       end
 
-      def self.build_parent_template(template, context)
+      def build_parent_template(template)
         # just check if the template contains the extends keyword
         fullpath = template.scan(/\{% extends (\w+) %\}/).flatten.first
 
@@ -68,13 +73,11 @@ module Locomotive
 
           return if fullpath == 'parent'
 
-          self.add_page(fullpath, context)
+          self.add_page(fullpath)
         end
       end
 
-      def self.find_parent(fullpath, context)
-        site = context[:site]
-
+      def find_parent(fullpath)
         segments = fullpath.split('/')
 
         return site.pages.index.first if segments.size == 1
@@ -86,12 +89,10 @@ module Locomotive
         # look for a local index page in db
         parent = site.pages.where(:fullpath => parent_fullpath).first
 
-        parent || self.add_page(parent_fullpath, context)
+        parent || self.add_page(parent_fullpath)
       end
 
-      def self.add_index_and_404(context)
-        site, pages, theme_path = context[:site], context[:database]['site']['pages'], context[:theme_path]
-
+      def add_index_and_404
         %w(index 404).each_with_index do |slug, position|
           page = site.pages.where({ :slug => slug, :depth => 0 }).first
 
@@ -99,7 +100,11 @@ module Locomotive
 
           template = File.read(File.join(theme_path, 'templates', "#{slug}.liquid"))
 
-          page.attributes = { :raw_template => template, :position => position }.merge(pages[slug] || {})
+          self.replace_images!(template)
+
+          page.attributes = { :raw_template => template }.merge(self.pages[slug] || {})
+
+          page.position = position
 
           page.save! rescue nil # TODO better error handling
 
@@ -109,6 +114,54 @@ module Locomotive
         end
       end
 
+      def replace_images!(template)
+        return if template.blank?
+
+        template.gsub!(/\/samples\/(.*\.[a-zA-Z0-9]{3})/) do |match|
+          name = $1
+
+          collection = AssetCollection.find_or_create_internal(site)
+
+          if asset = collection.assets.detect { |a| a.source_filename == name }
+            asset.source.url
+          else
+            match
+          end
+        end
+      end
+
+      def pages
+        @pages ||= self.retrieve_pages
+      end
+
+      def retrieve_pages
+        pages = context[:database]['site']['pages']
+
+        if pages.is_a?(Array) # ordered list of pages
+          tmp, positions = {}, Hash.new(0)
+          pages.each do |data|
+            position = nil
+            fullpath = data.keys.first.to_s
+
+            unless %w(index 404).include?(fullpath)
+              (segments = fullpath.split('/')).pop
+              position_key = segments.empty? ? 'index' : segments.join('/')
+
+              position = positions[position_key]
+
+              positions[position_key] += 1
+            end
+
+            attributes = (data.values.first || {}).merge(:position => position)
+
+            tmp[fullpath] = attributes
+          end
+          pages = tmp
+        end
+
+        pages
+      end
+
     end
   end
 end