locomotive_cms 0.0.3.3 → 0.0.4.beta1

data/lib/locomotive/heroku.rb

@@ -1,59 +1,61 @@
 require 'heroku'
+require 'heroku/client'
+require 'locomotive/heroku/custom_domain'
 
 module Locomotive
   module Heroku
-    
+
     extend ActiveSupport::Concern
-    
+
     included do
       class << self
         attr_accessor :heroku_connection
         attr_accessor :heroku_domains
       end
     end
-    
+
     module ClassMethods
-      
+
       def heroku?
         !self.config.heroku.nil? && self.config.heroku.respond_to?(:[])
       end
-            
+
       def enable_heroku
         raise 'Heroku application name is mandatory' if self.config.heroku[:name].blank?
-        
+
         self.open_heroku_connection
         self.enhance_site_model
-        
+
         # "cache" domains for better performance
         self.heroku_domains = self.heroku_connection.list_domains(self.config.heroku[:name]).collect { |h| h[:domain] }
       end
-      
+
       def open_heroku_connection
         login = self.config.heroku[:login] || ENV['HEROKU_LOGIN']
         password = self.config.heroku[:password] || ENV['HEROKU_PASSWORD']
-        
+
         self.heroku_connection = ::Heroku::Client.new(login, password)
       end
-      
+
       def enhance_site_model
         Site.send :include, Locomotive::Heroku::CustomDomain
       end
-      
+
       # manage domains
-      
+
       def add_heroku_domain(name)
         Locomotive.logger "[add heroku domain] #{name}"
         self.heroku_connection.add_domain(self.config.heroku[:name], name)
         self.heroku_domains << name
       end
-      
+
       def remove_heroku_domain(name)
         Locomotive.logger "[remove heroku domain] #{name}"
         self.heroku_connection.remove_domain(self.config.heroku[:name], name)
         self.heroku_domains.delete(name)
       end
-      
+
     end
-    
+
   end
-end
+end

data/lib/locomotive/httparty/patches.rb

@@ -2,17 +2,17 @@ require 'crack/json'
 
 module Crack
   class JSON
-    
+
     def self.parse_with_tumblr(json)
       cleaned_json = json.gsub(/^var\s+.+\s+=\s+/, '').gsub(/;$/, '')
       parse_without_tumblr(cleaned_json)
     rescue ArgumentError => e
       raise ParseError, "Invalid JSON string #{e.inspect}"
     end
-    
+
     class << self
       alias_method_chain :parse, :tumblr
     end
-    
+
   end
-end
+end

data/lib/locomotive/httparty/webservice.rb

@@ -1,7 +1,7 @@
 module Locomotive
   module Httparty
     class Webservice
-      
+
       include ::HTTParty
 
       def self.consume(url, options = {})
@@ -15,11 +15,11 @@ module Locomotive
 
         path ||= '/'
 
-        puts "[WebService] consuming #{path}, #{options.inspect}"
+        # puts "[WebService] consuming #{path}, #{options.inspect}"
 
         self.get(path, options).try(:underscore_keys)
       end
-      
+
     end
   end
-end
+end

data/lib/locomotive/httparty.rb

@@ -1,2 +1,2 @@
 require 'locomotive/httparty/webservice'
-require 'locomotive/httparty/patches'
+require 'locomotive/httparty/patches'

data/lib/locomotive/import/asset_collections.rb

@@ -0,0 +1,53 @@
+module Locomotive
+  module Import
+    module AssetCollections
+
+      def self.process(context)
+        site, database = context[:site], context[:database]
+
+        asset_collections = database['site']['asset_collections']
+
+        return if asset_collections.nil?
+
+        asset_collections.each do |name, attributes|
+          puts "....asset_collection = #{attributes['slug']}"
+
+          asset_collection = site.asset_collections.where(:slug => attributes['slug']).first
+
+          asset_collection ||= self.build_asset_collection(site, attributes.merge(:name => name))
+
+          self.add_or_update_fields(asset_collection, attributes['fields'])
+
+          asset_collection.save!
+
+          site.reload
+        end
+      end
+
+      def self.build_asset_collection(site, data)
+        attributes = { :internal => false }.merge(data)
+
+        attributes.delete_if { |name, value| %w{fields assets}.include?(name) }
+
+        site.asset_collections.build(attributes)
+      end
+
+      def self.add_or_update_fields(asset_collection, fields)
+        fields.each_with_index do |data, position|
+          name, data = data.keys.first, data.values.first
+
+          attributes = { :_alias => name, :label => name.humanize, :kind => 'string', :position => position }.merge(data).symbolize_keys
+
+          field = asset_collection.asset_custom_fields.detect { |f| f._alias == attributes[:_alias] }
+
+          field ||= asset_collection.asset_custom_fields.build(attributes)
+
+          field.send(:set_unique_name!) if field.new_record?
+
+          field.attributes = attributes
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/import/assets.rb

@@ -0,0 +1,74 @@
+module Locomotive
+  module Import
+    module Assets
+
+      def self.process(context)
+        site, theme_path = context[:site], context[:theme_path]
+
+        whitelist = self.build_regexps_in_withlist(context[:database]['site']['assets']['whitelist']) rescue nil
+
+        self.add_theme_assets(site, theme_path, whitelist)
+
+        self.add_other_assets(site, theme_path)
+      end
+
+      def self.add_theme_assets(site, theme_path, 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'), ''))
+
+            folder = asset_path.gsub(File.join(theme_path, 'public'), '').gsub(File.basename(asset_path), '').gsub(/^\//, '').gsub(/\/$/, '')
+
+            asset = site.theme_assets.where(:local_path => File.join(folder, File.basename(asset_path))).first
+
+            asset ||= site.theme_assets.build(:folder => folder)
+
+            asset.attributes = { :source => File.open(asset_path), :performing_plain_text => false, :hidden => !visible }
+
+            asset.save!
+
+            site.reload
+          end
+        end
+      end
+
+      def self.add_other_assets(site, theme_path)
+        collection = AssetCollection.find_or_create_internal(site)
+
+        Dir[File.join(theme_path, 'public', 'samples', '*')].each do |asset_path|
+
+          next if File.directory?(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)
+        rules.collect do |rule|
+          if rule.start_with?('^')
+            Regexp.new(rule.gsub('/', '\/'))
+          else
+            rule
+          end
+        end
+      end
+
+      def self.check_against_whitelist(whitelist, path)
+        (whitelist || []).each do |rule|
+          case rule
+            when Regexp
+              return true if path =~ rule
+            when String
+              return true if path == rule
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/locomotive/import/content_types.rb

@@ -0,0 +1,84 @@
+module Locomotive
+  module Import
+    module ContentTypes
+
+      def self.process(context)
+        site, database = context[:site], context[:database]
+
+        content_types = database['site']['content_types']
+
+        return if content_types.nil?
+
+        content_types.each do |name, attributes|
+          puts "....content_type = #{attributes['slug']}"
+
+          content_type = site.content_types.where(:slug => attributes['slug']).first
+
+          content_type ||= self.build_content_type(site, attributes.merge(:name => name))
+
+          self.add_or_update_fields(content_type, attributes['fields'])
+
+          self.set_highlighted_field_name(content_type)
+
+          self.set_order_by_value(content_type)
+
+          self.set_group_by_value(content_type)
+
+          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)
+
+        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)
+        fields.each_with_index do |data, position|
+          name, data = data.keys.first, data.values.first
+
+          attributes = { :_alias => name, :label => name.humanize, :kind => 'string', :position => position }.merge(data).symbolize_keys
+
+          field = content_type.content_custom_fields.detect { |f| f._alias == attributes[:_alias] }
+
+          field ||= content_type.content_custom_fields.build(attributes)
+
+          field.send(:set_unique_name!) if field.new_record?
+
+          field.attributes = attributes
+        end
+      end
+
+      def self.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)
+        order_by = (case content_type.order_by
+        when 'manually', '_position_in_list' then '_position_in_list'
+        when 'date', 'updated_at' then 'updated_at'
+        else
+          content_type.content_custom_fields.detect { |f| f._alias == content_type.order_by }._name rescue nil
+        end)
+
+        content_type.order_by = order_by || '_position_in_list'
+      end
+
+      def self.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 }
+
+        content_type.group_by_field_name = field._name if field
+      end
+
+    end
+  end
+end

data/lib/locomotive/import/job.rb

@@ -0,0 +1,73 @@
+require 'zip/zipfilesystem'
+
+module Locomotive
+  module Import
+    class Job
+
+      def initialize(theme_file, site = nil, enabled = {})
+        raise "Theme zipfile not found" unless File.exists?(theme_file)
+
+        @theme_file = theme_file
+        @site = site
+        @enabled = enabled
+      end
+
+      def before(worker)
+        @worker = worker
+      end
+
+      def perform
+        puts "theme_file = #{@theme_file} / #{@site.present?} / #{@enabled.inspect}"
+
+        self.unzip!
+
+        raise "No database.yml found in the theme zipfile" if @database.nil?
+
+        context = {
+          :database => @database,
+          :site => @site,
+          :theme_path => @theme_path,
+          :error => nil,
+          :worker => @worker
+        }
+
+        %w(site content_types assets asset_collections snippets pages).each do |step|
+          if @enabled[step] != false
+            "Locomotive::Import::#{step.camelize}".constantize.process(context)
+            @worker.update_attributes :step => step if @worker
+          else
+            puts "skipping #{step}"
+          end
+        end
+      end
+
+      protected
+
+      def unzip!
+        Zip::ZipFile.open(@theme_file) do |zipfile|
+          destination_path = File.join(Rails.root, 'tmp', 'themes', @site.id.to_s)
+
+          FileUtils.rm_r destination_path, :force => true
+
+          zipfile.each do |entry|
+            next if entry.name =~ /__MACOSX/
+
+            if entry.name =~ /database.yml$/
+
+              @database = YAML.load(zipfile.read(entry.name))
+              @theme_path = File.join(destination_path, entry.name.gsub('database.yml', ''))
+
+              next
+            end
+
+            FileUtils.mkdir_p(File.dirname(File.join(destination_path, entry.name)))
+
+            zipfile.extract(entry, File.join(destination_path, entry.name))
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/import/pages.rb

@@ -0,0 +1,114 @@
+module Locomotive
+  module Import
+    module Pages
+
+      def self.process(context)
+        site, pages, theme_path = context[:site], context[:database]['pages'], context[:theme_path]
+
+        context[:done] = {} # initialize the hash storing pages already processed
+
+        self.add_index_and_404(context)
+
+        Dir[File.join(theme_path, 'templates', '**/*')].each do |template_path|
+
+          fullpath = template_path.gsub(File.join(theme_path, 'templates'), '').gsub('.liquid', '').gsub(/^\//, '')
+
+          next if %w(index 404).include?(fullpath)
+
+          self.add_page(fullpath, context)
+        end
+      end
+
+      def self.add_page(fullpath, context)
+        puts "....adding #{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)
+
+        parent = self.find_parent(fullpath, context)
+
+        page = site.pages.where(:fullpath => fullpath).first || site.pages.build
+
+        attributes = {
+          :title        => fullpath.split('/').last.humanize,
+          :slug         => fullpath.split('/').last,
+          :parent       => parent,
+          :raw_template => template
+        }.merge(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
+        end
+
+        page.attributes = attributes
+
+        page.save!
+
+        site.reload
+
+        context[:done][fullpath] = page
+
+        page
+      end
+
+      def self.build_parent_template(template, context)
+        # just check if the template contains the extends keyword
+        fullpath = template.scan(/\{% extends (\w+) %\}/).flatten.first
+
+        if fullpath # inheritance detected
+          fullpath.gsub!("'", '')
+
+          return if fullpath == 'parent'
+
+          self.add_page(fullpath, context)
+        end
+      end
+
+      def self.find_parent(fullpath, context)
+        site = context[:site]
+
+        segments = fullpath.split('/')
+
+        return site.pages.index.first if segments.size == 1
+
+        segments.pop
+
+        parent_fullpath = segments.join('/').gsub(/^\//, '')
+
+        # look for a local index page in db
+        parent = site.pages.where(:fullpath => parent_fullpath).first
+
+        parent || self.add_page(parent_fullpath, context)
+      end
+
+      def self.add_index_and_404(context)
+        site, pages, theme_path = context[:site], context[:database]['site']['pages'], context[:theme_path]
+
+        %w(index 404).each_with_index do |slug, position|
+          page = site.pages.where({ :slug => slug, :depth => 0 }).first
+
+          page ||= sites.pages.build(:slug => slug, :parent => nil)
+
+          template = File.read(File.join(theme_path, 'templates', "#{slug}.liquid"))
+
+          page.attributes = { :raw_template => template, :position => position }.merge(pages[slug] || {})
+
+          page.save! rescue nil # TODO better error handling
+
+          site.reload
+
+          context[:done][slug] = page
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/import/site.rb

@@ -0,0 +1,17 @@
+module Locomotive
+  module Import
+    module Site
+
+      def self.process(context)
+        site, database = context[:site], context[:database]
+
+        attributes = database['site'].clone.delete_if { |name, value| %w{pages assets content_types asset_collections}.include?(name) }
+
+        site.attributes = attributes
+
+        site.save!
+      end
+
+    end
+  end
+end

data/lib/locomotive/import/snippets.rb

@@ -0,0 +1,23 @@
+module Locomotive
+  module Import
+    module Snippets
+
+      def self.process(context)
+        site, theme_path = context[:site], context[:theme_path]
+
+        Dir[File.join(theme_path, 'snippets', '*')].each do |snippet_path|
+
+          name = File.basename(snippet_path, File.extname(snippet_path)).parameterize('_')
+          
+          snippet = site.snippets.where(:slug => name).first || site.snippets.build(:name => name)
+
+          snippet.template = File.read(snippet_path) # = site.snippets.create! :name => name, :template => 
+          
+          snippet.save!
+          # puts "snippet = #{snippet.inspect}"
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/import.rb

@@ -0,0 +1,7 @@
+require 'locomotive/import/job'
+require 'locomotive/import/site'
+require 'locomotive/import/assets'
+require 'locomotive/import/asset_collections'
+require 'locomotive/import/content_types'
+require 'locomotive/import/snippets'
+require 'locomotive/import/pages'

data/lib/locomotive/inherited_resources.rb

@@ -1,3 +1,4 @@
+require 'responders'
 require 'inherited_resources'
 require 'inherited_resources/actions'
 require 'inherited_resources/responder'
@@ -35,12 +36,12 @@ module InheritedResources
       options[:location] ||= collection_url rescue nil
 
       destroy_resource(object)
-        
+
       options[:alert] = object.errors.full_messages.first # display the first error if present
-  
+
       respond_with_dual_blocks(object, options, &block)
     end
     alias :destroy! :destroy
-    
+
   end
-end
+end

data/lib/locomotive/liquid/drops/asset.rb

@@ -0,0 +1,21 @@
+module Locomotive
+  module Liquid
+    module Drops
+      class Asset < Base
+
+        def before_method(meth)
+          return '' if @source.nil?
+
+          if not @@forbidden_attributes.include?(meth.to_s)
+            value = @source.send(meth)
+          end
+        end
+
+        def url
+          @source.source.url
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/liquid/drops/asset_collections.rb

@@ -1,19 +1,54 @@
-module Locomotive  
-  module Liquid  
+module Locomotive
+  module Liquid
     module Drops
-  
-      class AssetCollections < ::Liquid::Drop  
-    
-        def initialize(site)
-          @site = site
+
+      class AssetCollections < ::Liquid::Drop
+
+        def before_method(meth)
+          collection = @context.registers[:site].asset_collections.where(:slug => meth.to_s).first
+          AssetCollectionProxy.new(collection)
+        end
+
+      end
+
+      class AssetCollectionProxy < ::Liquid::Drop
+
+        def initialize(collection)
+          @collection = collection
+        end
+
+        def first
+          @collection.assets.first
+        end
+
+        def last
+          @collection.assets.last
+        end
+
+        def each(&block)
+          @collection.assets.each(&block)
+        end
+
+        def paginate(options = {})
+          paginated_collection = @collection.assets.paginate(options)
+          {
+            :collection       => paginated_collection,
+            :current_page     => paginated_collection.current_page,
+            :previous_page    => paginated_collection.previous_page,
+            :next_page        => paginated_collection.next_page,
+            :total_entries    => paginated_collection.total_entries,
+            :total_pages      => paginated_collection.total_pages,
+            :per_page         => paginated_collection.per_page
+          }
         end
-  
+
         def before_method(meth)
-          @site.asset_collections.where(:slug => meth.to_s)
+          return '' if @collection.nil?
+          @collection.send(meth)
         end
-  
+
       end
-    
+
     end
   end
-end
+end