adva-static 0.0.9 → 0.0.11

data/lib/adva/static/import/model/section.rb

@@ -3,46 +3,40 @@ module Adva
     class Import
       module Model
         class Section < Base
-          class << self
-            def types
-              [Blog, Page]
-            end
+          attr_reader :parent
 
-            def recognize(sources)
-              types.map { |type| type.recognize(sources) }.flatten.compact.sort
-            end
-          end
-
-          def attribute_names
-            @attribute_names ||= [:site_id, :type, :name, :slug, :path]
+          def initialize(source, site = nil, parent = nil)
+            super(source)
+            @site = site
+            @parent = parent
           end
 
           def record
-            @record ||= site.send(model.name.underscore.pluralize).find_or_initialize_by_path(path)
+            @record ||= model.find_or_initialize_by_slug(source.data.slug)
           end
 
-          def site
-            @site ||= Site.new(source.root).record
+          def attribute_names
+            @attribute_names ||= super | [:site_id, :parent_id, :type, :name, :slug]
           end
 
           def type
-            model.name
+            model_name
           end
 
-          def name
-            @name ||= source.root? ? 'Home' : source.basename.titleize
+          def site
+            @site ||= Site.new(source.path.root)
           end
 
-          def slug
-            @slug ||= source.root? ? SimpleSlugs::Slug.new(name) : super
+          def site_id
+            site && site.record.persisted? ? site.record.id.to_s : nil
           end
 
-          def path
-            @path ||= source.root? ? slug : super
+          def parent
+            @parent ||= source.path.root? || source.path.parent.root? ? nil : Section.new(source.path.parent)
           end
 
-          def loadable
-            @loadable ||= source.root? ? Source.new('index', source.root).find_or_self.full_path : source.full_path
+          def parent_id
+            parent && parent.record.persisted? ? parent.record.id.to_s : nil
           end
         end
       end

data/lib/adva/static/import/model/site.rb

@@ -3,53 +3,29 @@ module Adva
     class Import
       module Model
         class Site < Base
-          class << self
-            def recognize(sources)
-              sources.map { |source| new(sources.delete(source).root) if source.path == 'site' }.compact
-            end
-          end
-
-          def initialize(root)
-            super(Source.new('', root))
-          end
+          delegate :host, :to => :'source.data'
 
-          def attribute_names
-            @attribute_names ||= [:account, :host, :name, :title, :sections_attributes]
+          def update!
+            record.account = Account.first || Account.create
+            super
+            sections.each { |section| section.update! }
           end
 
           def record
             @record ||= model.find_or_initialize_by_host(host)
           end
 
-          def host
-            @host ||= File.basename(source.root)
-          end
-
-          def name
-            @name ||= host
-          end
-
-          def title
-            @title ||= name
-          end
-
-          def account
-            @account ||= ::Account.first || ::Account.new
-          end
-
-          def sections_attributes
-            sections.map(&:attributes)
+          def attribute_names
+            @attribute_names ||= (super | [:host, :name, :title]) - [:sections]
           end
 
           def sections
-            @sections ||= Section.recognize(source.files).tap do |sections|
-              sections << Page.new(Source.new('index', source.root).find_or_self) if sections.empty?
+            @sections ||= begin
+              sections = source.sections.map { |section| Model.build(section, self) }
+              sections << Page.new(source.path) if sections.empty?
+              sections
             end
           end
-
-          def loadable
-            @loadable ||= Source.new('site', source.root).find_or_self.full_path
-          end
         end
       end
     end

data/lib/adva/static/import/source.rb

@@ -1,80 +1,25 @@
 module Adva
   class Static
     class Import
-      class Source < Pathname
-        TYPES = ['html', 'jekyll', 'yml']
-        EXTENSIONS = TYPES.map { |type| ".#{type}" }
-
-        attr_reader :root
-
-        delegate :exist?, :to => :full_path
-
-        def initialize(path, root = nil)
-          root ||= path.root if path.respond_to?(:root)
-          @root = Pathname.new(root.to_s)
-
-          path = path.to_s.gsub(root, '') if root
-          path = path.to_s[1..-1] if path.to_s[0, 1] == '/'
-          super(path)
-        end
-
-        def find_or_self
-          find or self
-        end
-
-        def find
-          file = Dir["#{root.join(path)}.{#{TYPES.join(',')}}"].first
-          Source.new(file, root) if file
-        end
-
-        def all
-          @all ||= Dir[root.join(path).join("**/*.{#{TYPES.join(',')}}")].map { |path| Source.new(path, root) }
-        end
-
-        def files
-          files = path == 'index' ? directory.all : all
-          files.reject { |path| path.basename == 'site' }.sort
-        end
-
-        def root?
-          @_root ||= path == 'index' || full_path.to_s == root.to_s
-        end
-
-        def directory
-          @directory ||= self.class.new(dirname, root)
-        end
-
-        def basename
-          @basename ||= super.to_s.sub(/\.\w+$/, '')
-        end
-
-        def dirname
-          @dirname ||= super.to_s.sub(/^.$/, '')
-        end
-
-        def path
-          @_path ||= [dirname, basename].select(&:present?).join('/')
-        end
-
-        def full_path
-          @full_path ||= root.join(self)
-        end
-
-        def self_and_parents
-          parents << self
-        end
-
-        def parents
-          @parents ||= begin
-            parts = self.to_s.split('/')[0..-2]
-            parts.inject([]) do |parents, part|
-              parents << Source.new(parts[0..parents.size].join('/'), root)
-            end
+      module Source
+        autoload :Base,    'adva/static/import/source/base'
+        autoload :Blog,    'adva/static/import/source/blog'
+        autoload :Path,    'adva/static/import/source/path'
+        autoload :Page,    'adva/static/import/source/page'
+        autoload :Post,    'adva/static/import/source/post'
+        autoload :Section, 'adva/static/import/source/section'
+        autoload :Site,    'adva/static/import/source/site'
+
+        TYPES = [Site] + Section::TYPES
+
+        class << self
+          def build(type, path)
+            const_get(type).new(path)
           end
-        end
 
-        def <=>(other)
-          path == 'index' ? -1 : other.path == 'index' ? 1 : path <=> other.path
+          def recognize(paths)
+            [Site, Post, Section].map { |type| type.recognize(paths) }.flatten.compact.sort
+          end
         end
       end
     end

data/lib/adva/static/import/source/base.rb

@@ -0,0 +1,59 @@
+require 'hashr'
+
+module Adva
+  class Static
+    class Import
+      module Source
+        class Base
+          delegate :exist?, :to => :path
+
+          attr_reader :path
+
+          def initialize(path)
+            @path = normalize_path(path)
+          end
+
+          def to_hash
+            data
+          end
+
+          def data
+            @data ||= Hashr.new(read || {})
+          end
+
+          def model_name
+            @model_name ||= self.class.name.demodulize
+          end
+
+          def <=>(other)
+            path <=> other.path
+          end
+
+          protected
+
+            def normalize_path(path)
+              path = path.is_a?(Path) ? path : Path.new(path)
+              path = path.parent if path.filename == 'index'
+              path
+            end
+
+            def loadable
+              raise "path #{path.inspect} is not a file" unless path.file?
+              path
+            end
+
+            def read
+              @read ||= begin
+                format = Format.for(loadable) if loadable.exist?
+                data = format.read if format
+                Hashr.new(data || {})
+              end
+            end
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/adva/static/import/source/blog.rb

@@ -0,0 +1,37 @@
+module Adva
+  class Static
+    class Import
+      module Source
+        class Blog < Section
+          class << self
+            def recognize(paths)
+              posts = Post.recognize(paths)
+              blogs = posts.map { |post| post.strip_permalink }.flatten.uniq
+              blogs = blogs.map { |blog| paths.detect { |path| blog.to_s == path.to_s } || blog }
+
+              paths.replace(paths - blogs)
+              blogs.map { |path| new(path, posts) }
+            end
+          end
+
+          attr_reader :posts
+
+          def initialize(path, posts = [])
+            @posts = posts
+            super(path)
+          end
+
+          def categories
+            @categories ||= posts.map { |post| post.categories }.flatten.uniq.sort
+          end
+
+          def data
+            super.merge(:posts => posts, :categories => categories)
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/adva/static/import/source/page.rb

@@ -0,0 +1,17 @@
+module Adva
+  class Static
+    class Import
+      module Source
+        class Page < Section
+          class << self
+            def recognize(paths)
+              paths.map { |path| new(path) }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/adva/static/import/source/path.rb

@@ -0,0 +1,84 @@
+module Adva
+  class Static
+    class Import
+      module Source
+        class Path < Pathname
+          TYPES = ['html', 'jekyll', 'yml']
+          EXTENSIONS = TYPES.map { |type| ".#{type}" }
+
+          attr_reader :root
+
+          def initialize(path, root = nil)
+            super(path)
+            @root = self.class.new(root.to_s) if root && to_s != root.to_s
+          end
+
+          def root?
+            !@root || filename == 'index' && parent.root? || @root.to_s == to_s # i.e. this is the root path if no root is set
+          end
+
+          def root
+            root? ? self : @root
+          end
+
+          def parent
+            self.class.new(super, @root || self)
+          end
+
+          def self_and_parents
+            parents << self
+          end
+
+          def parents
+            parts = to_s.split('/')[0..-2]
+            parts.inject([]) { |parents, part| parents << self.class.new(parts[0..parents.size].join('/'), root) }
+          end
+
+          def self_and_descendants
+            [self] + descendants
+          end
+
+          def descendants
+            Dir[join("**/*.{#{TYPES.join(',')}}")].map { |child| join(child.gsub(/#{to_s}\/?/, '')) }
+          end
+
+          def local
+            gsub(root ? "#{root}/" : '', '')
+          end
+
+          def filename
+            basename.gsub(extname, '')
+          end
+
+          def join(other)
+            self.class.new(super, root)
+            # self.class.new(super(other.gsub(/^\//, '')), root)
+          end
+
+          def gsub(pattern, replacement)
+            self.class.new(to_s.gsub(pattern, replacement), root)
+          end
+
+          def glob
+            paths = Dir[join('**/*')].map { |child| join(child.gsub("#{to_s}/", '')) }
+            paths = paths.map { |path| path.filename == 'index' ? path.parent : path }
+            paths.sort
+          end
+
+          def find(name)
+            path = Dir["#{join(name)}.{#{TYPES.join(',')}}"].first
+            self.class.new(path, root) if path
+          end
+
+          def <=>(other)
+            root? ? -1 : other.root? ? 1 : to_s <=> other.to_s
+          end
+
+          def ==(other)
+            to_s == other.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adva/static/import/source/post.rb

@@ -0,0 +1,67 @@
+require 'simple_slugs'
+
+module Adva
+  class Static
+    class Import
+      module Source
+        class Post < Base
+          PERMALINK = %r((?:^|/)(\d{4})(?:\-|\/)(\d{1,2})(?:\-|\/)(\d{1,2})(?:\-|\/)(.*)$)
+
+          class << self
+            def recognize(paths)
+              posts = paths.map { |path| path.self_and_descendants }.flatten.select { |path| permalink?(path) }
+              posts = posts.map { |path| new(path) }
+              paths.replace(paths - posts.map(&:permalink_paths).flatten)
+              posts
+            end
+
+            def permalink?(path)
+              path.to_s =~ PERMALINK
+            end
+          end
+
+          def categories
+            @categories ||= Array(read.categories).map { |category| category.split(',') }.flatten.map(&:strip)
+          end
+
+          def title
+            @title ||= read.title || path_tokens.last.titleize
+          end
+
+          def slug
+            @slug ||= read.slug || SimpleSlugs::Slug.new(title).to_s
+          end
+
+          def published_at
+            @published_at ||= DateTime.civil(*permalink[0..-2].map(&:to_i))
+          end
+
+          def permalink
+            @permalink ||= path_tokens.to_a[0..-2] << slug
+          end
+
+          def permalink_paths
+            path.self_and_parents - path.root.self_and_parents
+          end
+
+          def strip_permalink
+            path.gsub(Post::PERMALINK, '')
+          end
+
+          def data
+            super.merge(:categories => categories, :title => title, :slug => slug, :published_at => published_at)
+          end
+
+          protected
+
+            def path_tokens
+              @path_tokens ||= path.to_s.gsub(/\.\w+$/, '').match(PERMALINK).to_a[1..-1]
+            end
+        end
+      end
+    end
+  end
+end
+
+
+