comfortable_mexican_sofa 1.12.11 → 2.0.0

data/lib/comfortable_mexican_sofa/extensions/is_mirrored.rb

@@ -1,86 +0,0 @@
-module ComfortableMexicanSofa::IsMirrored
-  
-  def self.included(base)
-    base.send :extend, ClassMethods
-  end
-  
-  module ClassMethods
-    def cms_is_mirrored
-      include ComfortableMexicanSofa::IsMirrored::InstanceMethods
-      
-      attr_accessor :is_mirrored
-      
-      after_save    :sync_mirror
-      after_destroy :destroy_mirror
-    end
-  end
-  
-  module InstanceMethods
-    
-    # Mirrors of the object found on other sites
-    def mirrors
-      return [] unless self.site.is_mirrored?
-      (Comfy::Cms::Site.mirrored - [self.site]).collect do |site|
-        case self
-          when Comfy::Cms::Layout  then site.layouts.find_by_identifier(self.identifier)
-          when Comfy::Cms::Page    then site.pages.find_by_full_path(self.full_path)
-          when Comfy::Cms::Snippet then site.snippets.find_by_identifier(self.identifier)
-        end
-      end.compact
-    end
-    
-    # Creating or updating a mirror object. Relationships are mirrored
-    # but content is unique. When updating need to grab mirrors based on
-    # self.slug_was, new objects will use self.slug.
-    def sync_mirror
-      return if self.is_mirrored || !self.site.is_mirrored?
-      
-      (Comfy::Cms::Site.mirrored - [self.site]).each do |site|
-        mirror = case self
-        when Comfy::Cms::Layout
-          m = site.layouts.find_by_identifier(self.identifier_was || self.identifier) || site.layouts.new
-          m.attributes = {
-            :identifier => self.identifier,
-            :parent_id  => site.layouts.find_by_identifier(self.parent.try(:identifier)).try(:id)
-          }
-          m
-        when Comfy::Cms::Page
-          m = site.pages.find_by_full_path(self.full_path_was || self.full_path) || site.pages.new
-          m.attributes = {
-            :slug       => self.slug,
-            :label      => m.label.blank?? self.label : m.label,
-            :parent_id  => site.pages.find_by_full_path(self.parent.try(:full_path)).try(:id),
-            :layout     => site.layouts.find_by_identifier(self.layout.try(:identifier))
-          }
-          m
-        when Comfy::Cms::Snippet
-          m = site.snippets.find_by_identifier(self.identifier_was || self.identifier) || site.snippets.new
-          m.attributes = {
-            :identifier => self.identifier
-          }
-          m
-        end
-        
-        mirror.is_mirrored = true
-        begin
-          mirror.save!
-        rescue ActiveRecord::RecordInvalid => e
-          logger.error(e.message)
-          logger.error(e.backtrace.each{|line| error line })
-        end
-      end
-    end
-    
-    # Mirrors should be destroyed
-    def destroy_mirror
-      return if self.is_mirrored || !self.site.is_mirrored?
-      mirrors.each do |mirror|
-        mirror.is_mirrored = true
-        mirror.destroy
-      end
-    end
-  end
-  
-end
-
-ActiveRecord::Base.send :include, ComfortableMexicanSofa::IsMirrored

data/lib/comfortable_mexican_sofa/extensions/rails.rb

@@ -1,17 +0,0 @@
-class String
-  # Converts string to something suitable to be used as an element id
-  def slugify
-    self.strip.gsub(/\W|_/, '-').gsub(/\s|^_*|_*$/, '').squeeze('-')
-  end
-end
-
-module Enumerable
-  # Like a normal collect, only with index
-  def collect_with_index
-    result = []
-    self.each_with_index do |elt, idx|
-      result << yield(elt, idx)
-    end
-    result
-  end
-end

data/lib/comfortable_mexican_sofa/fixture.rb

@@ -1,82 +0,0 @@
-module ComfortableMexicanSofa::Fixture
-  
-  class Importer
-    attr_accessor :site,
-                  :path,
-                  :from,
-                  :to,
-                  :fixture_ids,
-                  :force_import
-    
-    def initialize(from, to = from, force_import = false)
-      self.from         = from
-      self.to           = to
-      self.site         = Comfy::Cms::Site.where(:identifier => to).first!
-      self.fixture_ids  = []
-      self.force_import = force_import
-      
-      dir = self.class.name.split('::')[2].downcase.pluralize
-      self.path = ::File.join(ComfortableMexicanSofa.config.fixtures_path, from, dir, '/')
-    end
-    
-    def fresh_fixture?(object, file_path)
-      object.new_record? || self.force_import || ::File.mtime(file_path) > object.updated_at
-    end
-    
-    def get_attributes(file_path)
-      YAML.load_file(file_path) || { }
-    end
-    
-    def save_categorizations!(object, categories)
-      object.categorizations.delete_all
-      
-      [categories].flatten.compact.each do |label|
-        category = self.site.categories.where(
-          :label            => label,
-          :categorized_type => object.class.to_s
-        ).first
-        
-        next unless category
-        
-        category.categorizations.create!(:categorized => object)
-      end
-    end
-    
-    def import!
-      ComfortableMexicanSofa::Fixture::Category::Importer.new(from, to, force_import).import!
-      ComfortableMexicanSofa::Fixture::Layout::Importer.new(  from, to, force_import).import!
-      ComfortableMexicanSofa::Fixture::Page::Importer.new(    from, to, force_import).import!
-      ComfortableMexicanSofa::Fixture::Snippet::Importer.new( from, to, force_import).import!
-      ComfortableMexicanSofa::Fixture::File::Importer.new(    from, to, force_import).import!
-    end
-  end
-  
-  class Exporter
-    attr_accessor :site,
-                  :path,
-                  :from,
-                  :to
-    
-    def initialize(from, to = from)
-      self.from = from
-      self.to   = to
-      self.site = Comfy::Cms::Site.where(:identifier => from).first!
-      dir = self.class.name.split('::')[2].downcase.pluralize
-      self.path = ::File.join(ComfortableMexicanSofa.config.fixtures_path, to, dir)
-    end
-    
-    def prepare_folder!(path)
-      FileUtils.rm_rf(path)
-      FileUtils.mkdir_p(path)
-    end
-    
-    def export!
-      ComfortableMexicanSofa::Fixture::File::Exporter.new(    from, to).export!
-      ComfortableMexicanSofa::Fixture::Category::Exporter.new(from, to).export!
-      ComfortableMexicanSofa::Fixture::Layout::Exporter.new(  from, to).export!
-      ComfortableMexicanSofa::Fixture::Page::Exporter.new(    from, to).export!
-      ComfortableMexicanSofa::Fixture::Snippet::Exporter.new( from, to).export!
-    end
-  end
-  
-end

data/lib/comfortable_mexican_sofa/fixture/category.rb

@@ -1,42 +0,0 @@
-module ComfortableMexicanSofa::Fixture::Category
-  class Importer < ComfortableMexicanSofa::Fixture::Importer
-    def import!
-      {
-        'files'     => 'Comfy::Cms::File',
-        'pages'     => 'Comfy::Cms::Page',
-        'snippets'  => 'Comfy::Cms::Snippet'
-      }.each do |file, type|
-        if File.exists?(attrs_path = File.join(path, "#{file}.yml"))
-          categories = [get_attributes(attrs_path)].flatten
-          existing_categories = self.site.categories.where(:categorized_type => type).map(&:label)
-          
-          self.site.categories.where(
-            :categorized_type => type,
-            :label            => existing_categories - categories
-          ).destroy_all
-          
-          (categories - existing_categories).each do |label|
-            self.site.categories.create(:label => label, :categorized_type => type)
-          end
-        end
-      end
-    end
-  end
-  
-  class Exporter < ComfortableMexicanSofa::Fixture::Exporter
-    def export!
-      prepare_folder!(self.path)
-      {
-        'files'     => 'Comfy::Cms::File',
-        'pages'     => 'Comfy::Cms::Page',
-        'snippets'  => 'Comfy::Cms::Snippet'
-      }.each do |file, type|
-        if (categories = self.site.categories.of_type(type)).present?
-          open(File.join(self.path, "#{file}.yml"), 'w') do |f|
-            f.write(categories.map{|c| c.label}.to_yaml)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/comfortable_mexican_sofa/fixture/file.rb

@@ -1,85 +0,0 @@
-module ComfortableMexicanSofa::Fixture::File
-  class Importer < ComfortableMexicanSofa::Fixture::Importer
-    def import!
-      Dir["#{self.path}[^_]*"].each do |file_path|
-        filename = ::File.basename(file_path)
-        file = self.site.files.where(:file_file_name => filename).first || self.site.files.new
-
-        # setting attributes
-        categories = []
-        if File.exists?(attrs_path = File.join(self.path, "_#{filename}.yml"))
-          if fresh_fixture?(file, attrs_path)
-            attrs = get_attributes(attrs_path)
-
-            block = if (attrs['page'] && attrs['block']) && (page = self.site.pages.find_by_full_path(attrs['page']))
-              page.blocks.find_by_identifier(attrs['block'])
-            end
-
-            file.label        = attrs['label']
-            file.description  = attrs['description']
-            categories        = attrs['categories']
-            file.block        = block
-          end
-        end
-
-        # setting actual file
-        if fresh_fixture?(file, file_path)
-          file.file = open(file_path)
-        end
-
-        if file.changed? || self.force_import
-          if file.save
-            save_categorizations!(file, categories)
-            ComfortableMexicanSofa.logger.info("[FIXTURES] Imported File \t #{file.file_file_name}")
-          else
-            ComfortableMexicanSofa.logger.warn("[FIXTURES] Failed to import File \n#{file.errors.inspect}")
-          end
-        end
-
-        self.fixture_ids << file.id
-      end
-
-      # cleaning up
-      self.site.files.where('id NOT IN (?) AND block_id IS NULL', fixture_ids).each{ |s| s.destroy }
-    end
-  end
-
-  class Exporter < ComfortableMexicanSofa::Fixture::Exporter
-    def export!
-      prepare_folder!(self.path)
-
-      self.site.files.each do |file|
-        file_path = File.join(self.path, file.file_file_name)
-        block = file.block
-        page = block.present?? block.blockable : nil
-
-        # writing attributes
-        open(::File.join(self.path, "_#{file.file_file_name}.yml"), 'w') do |f|
-          f.write({
-            'label'       => file.label,
-            'description' => file.description,
-            'categories'  => file.categories.map{|c| c.label},
-            'page'        => page.present?? page.full_path : nil,
-            'block'       => block.present?? block.identifier : nil
-          }.to_yaml)
-        end
-
-        # writing content
-        data_path = file.file.options[:storage] == :filesystem ?
-          file.file.path :
-          file.file.url
-
-        begin
-          open(::File.join(self.path, ::File.basename(file_path)), 'wb') do |f|
-            open(data_path) { |src| f.write(src.read) }
-          end
-        rescue Errno::ENOENT, OpenURI::HTTPError
-          ComfortableMexicanSofa.logger.warn("[FIXTURES] No physical File \t #{file.file_file_name}")
-          next
-        end
-
-        ComfortableMexicanSofa.logger.info("[FIXTURES] Exported File \t #{file.file_file_name}")
-      end
-    end
-  end
-end

data/lib/comfortable_mexican_sofa/fixture/layout.rb

@@ -1,95 +0,0 @@
-module ComfortableMexicanSofa::Fixture::Layout
-  class Importer < ComfortableMexicanSofa::Fixture::Importer
-    
-    def import!(path = self.path, parent = nil)
-      Dir["#{path}*/"].each do |path|
-        identifier = path.split('/').last
-        
-        layout = self.site.layouts.find_or_initialize_by(:identifier => identifier)
-        layout.parent = parent
-        
-        # setting attributes
-        if File.exists?(attrs_path = File.join(path, 'attributes.yml'))
-          if fresh_fixture?(layout, attrs_path)
-            attrs = get_attributes(attrs_path)
-            layout.label      = attrs['label']
-            layout.app_layout = attrs['app_layout'] || parent.try(:app_layout)
-            layout.position   = attrs['position'] if attrs['position']
-          end
-        end
-        
-        # setting content
-        %w(html haml).each do |extension|
-          if File.exists?(content_path = File.join(path, "content.#{extension}"))
-            if fresh_fixture?(layout, content_path)
-              layout.content = extension == "html" ? 
-                ::File.open(content_path).read : 
-                Haml::Engine.new(::File.open(content_path).read).render.rstrip
-            end
-          end
-        end
-        
-        if File.exists?(content_path = File.join(path, 'stylesheet.css'))
-          if fresh_fixture?(layout, content_path)
-            layout.css = File.open(content_path).read
-          end
-        end
-        if File.exists?(content_path = File.join(path, 'javascript.js'))
-          if fresh_fixture?(layout, content_path)
-            layout.js = File.open(content_path).read
-          end
-        end
-        
-        # saving
-        if layout.changed? || self.force_import
-          if layout.save
-            ComfortableMexicanSofa.logger.info("[FIXTURES] Imported Layout \t #{layout.identifier}")
-          else
-            ComfortableMexicanSofa.logger.warn("[FIXTURES] Failed to import Layout \n#{layout.errors.inspect}")
-          end
-        end
-        
-        self.fixture_ids << layout.id
-        
-        # importing child layouts
-        import!(path, layout)
-      end
-      
-      # cleaning up
-      unless parent
-        self.site.layouts.where('id NOT IN (?)', self.fixture_ids).each{ |s| s.destroy }
-      end
-    end
-  end
-
-  class Exporter < ComfortableMexicanSofa::Fixture::Exporter
-    def export!
-      prepare_folder!(self.path)
-      
-      self.site.layouts.each do |layout|
-        layout_path = File.join(path, layout.ancestors.reverse.collect{|l| l.identifier}, layout.identifier)
-        FileUtils.mkdir_p(layout_path)
-        
-        # writing attributes
-        open(File.join(layout_path, 'attributes.yml'), 'w') do |f|
-          f.write({
-            'label'       => layout.label,
-            'app_layout'  => layout.app_layout,
-            'position'    => layout.position
-          }.to_yaml)
-        end
-        open(File.join(layout_path, 'content.html'), 'w') do |f|
-          f.write(layout.content)
-        end
-        open(File.join(layout_path, 'stylesheet.css'), 'w') do |f|
-          f.write(layout.css)
-        end
-        open(File.join(layout_path, 'javascript.js'), 'w') do |f|
-          f.write(layout.js)
-        end
-        
-        ComfortableMexicanSofa.logger.info("[FIXTURES] Exported Layout \t #{layout.identifier}")
-      end
-    end
-  end
-end

data/lib/comfortable_mexican_sofa/fixture/page.rb

@@ -1,129 +0,0 @@
-module ComfortableMexicanSofa::Fixture::Page
-  class Importer < ComfortableMexicanSofa::Fixture::Importer
-
-    attr_accessor :target_pages
-
-    def import!(path = self.path, parent = nil)
-      Dir["#{path}*/"].each do |path|
-        slug = path.split('/').last
-
-        page = if parent
-          parent.children.where(:slug => slug).first || site.pages.new(:parent => parent, :slug => slug)
-        else
-          site.pages.root || site.pages.new(:slug => slug)
-        end
-
-        # setting attributes
-        categories = []
-        if File.exists?(attrs_path = File.join(path, 'attributes.yml'))
-          if fresh_fixture?(page, attrs_path)
-            attrs = get_attributes(attrs_path)
-
-            page.label        = attrs['label']
-            page.layout       = site.layouts.find_by(:identifier => attrs['layout']) || parent.try(:layout)
-            page.is_published = attrs['is_published'].nil?? true : attrs['is_published']
-            page.position     = attrs['position'] if attrs['position']
-
-            categories        = attrs['categories']
-
-            if attrs['target_page']
-              self.target_pages ||= {}
-              self.target_pages[page] = attrs['target_page']
-            end
-          end
-        end
-
-        # setting content
-        blocks_to_clear = page.blocks.collect(&:identifier)
-        blocks_attributes = [ ]
-        file_extentions = %w(html haml jpg png gif)
-        Dir.glob("#{path}/*.{#{file_extentions.join(',')}}").each do |block_path|
-          extention = File.extname(block_path)[1..-1]
-          identifier = block_path.split('/').last.gsub(/\.(#{file_extentions.join('|')})\z/, '')
-          blocks_to_clear.delete(identifier)
-          if fresh_fixture?(page, block_path)
-            content = case extention
-            when 'jpg', 'png', 'gif'
-              ::File.open(block_path)
-            when 'haml'
-              Haml::Engine.new(::File.open(block_path).read).render.rstrip
-            else
-              ::File.open(block_path).read
-            end
-
-            blocks_attributes << {
-              :identifier => identifier,
-              :content    => content
-            }
-          end
-        end
-
-        # deleting removed blocks
-        page.blocks.where(:identifier => blocks_to_clear).destroy_all
-
-        page.blocks_attributes = blocks_attributes if blocks_attributes.present?
-
-        # saving
-        if page.changed? || page.blocks_attributes_changed || self.force_import
-          if page.save
-            save_categorizations!(page, categories)
-            ComfortableMexicanSofa.logger.info("[FIXTURES] Imported Page \t #{page.full_path}")
-          else
-            ComfortableMexicanSofa.logger.warn("[FIXTURES] Failed to import Page \n#{page.errors.inspect}")
-          end
-        end
-
-        self.fixture_ids << page.id
-
-        # importing child pages
-        import!(path, page)
-      end
-
-      # linking up target pages
-      if self.target_pages.present?
-        self.target_pages.each do |page, target|
-          if target_page = self.site.pages.where(:full_path => target).first
-            page.target_page = target_page
-            page.save
-          end
-        end
-      end
-
-      # cleaning up
-      unless parent
-        self.site.pages.where('id NOT IN (?)', self.fixture_ids).each{ |s| s.destroy }
-      end
-    end
-  end
-
-  class Exporter < ComfortableMexicanSofa::Fixture::Exporter
-    def export!
-      prepare_folder!(self.path)
-
-      self.site.pages.each do |page|
-        page.slug = 'index' if page.slug.blank?
-        page_path = File.join(path, page.ancestors.reverse.collect{|p| p.slug.blank?? 'index' : p.slug}, page.slug)
-        FileUtils.mkdir_p(page_path)
-
-        open(File.join(page_path, 'attributes.yml'), 'w') do |f|
-          f.write({
-            'label'         => page.label,
-            'layout'        => page.layout.try(:identifier),
-            'parent'        => page.parent && (page.parent.slug.present?? page.parent.slug : 'index'),
-            'target_page'   => page.target_page.try(:full_path),
-            'categories'    => page.categories.map{|c| c.label},
-            'is_published'  => page.is_published,
-            'position'      => page.position
-          }.to_yaml)
-        end
-        page.blocks_attributes.each do |block|
-          open(File.join(page_path, "#{block[:identifier]}.html"), 'w') do |f|
-            f.write(block[:content])
-          end
-        end
-
-        ComfortableMexicanSofa.logger.info("[FIXTURES] Exported Page \t #{page.full_path}")
-      end
-    end
-  end
-end