adva-static 0.0.3 → 0.0.4

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

@@ -0,0 +1,33 @@
+module Adva
+  class Static
+    class Import
+      module Model
+        class Blog < Section
+          class << self
+            def recognize(sources)
+              return [] if sources.blank?
+
+              sources = Array(sources)
+              posts = sources.select { |source| Post.permalink?(source) }
+              posts = sources.map(&:directory).map(&:files).flatten.select { |s| Post.permalink?(s) } if posts.blank?
+
+              blogs = posts.map { |post| Post.new(post).section_source }.flatten.uniq
+              blogs = blogs.map { |blog| sources.detect { |source| blog.path == source.path } || blog }
+
+              sources.replace(sources - blogs - posts.map(&:self_and_parents).flatten)
+              blogs.map { |source| new(source) }
+            end
+          end
+
+          def attribute_names
+            @attribute_names ||= super + [:posts_attributes]
+          end
+
+          def posts_attributes
+            Post.recognize(source.files).map(&:attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Adva
+  class Static
+    class Import
+      module Model
+        class Page < Section
+          PATTERN = %r([\w-]+\.(#{Source::TYPES.join('|')})$)
+
+          class << self
+            def recognize(sources)
+              return [] if sources.blank?
+
+              pages = sources.select { |source| source.to_s =~ PATTERN }
+              sources.replace(sources - pages)
+
+              pages = pages.map { |source| source.self_and_parents.map(&:find_or_self) }.flatten.uniq
+              pages = pages.map { |source| new(source) }
+              pages
+            end
+          end
+
+          def attribute_names
+            @attribute_names ||= super + [:body]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Adva
+  class Static
+    class Import
+      module Model
+        class Post < Base
+          PERMALINK = %r((?:^|/)(\d{4})(?:\-|\/)(\d{1,2})(?:\-|\/)(\d{1,2})(?:\-|\/)(.*)$)
+
+          class << self
+            def recognize(sources)
+              posts = sources.select { |source| source.path =~ PERMALINK }
+              sources.replace(sources - posts.map(&:self_and_parents).flatten)
+              posts.map { |post| new(post) }
+            end
+
+            def permalink?(path)
+              path.to_s =~ PERMALINK
+            end
+
+            def strip_permalink(source)
+              Source.new(source.to_s.gsub(Post::PERMALINK, ''), source.root)
+            end
+          end
+
+          def attribute_names
+            @attribute_names ||= [:site_id, :section_id, :title, :body, :published_at]
+          end
+
+          def record
+            @record ||= section.posts.by_permalink(*permalink).all.first || section.posts.build
+          end
+
+          def site_id
+            section.site_id.to_s
+          end
+
+          def section
+            @section ||= Blog.new(section_source).record
+          end
+
+          def section_id
+            section.id.to_s
+          end
+
+          def section_source
+            @section_source ||= begin
+              source = self.class.strip_permalink(self.source)
+              if source.path.present?
+                source.find_or_self
+              else
+                Source.new(source.join('index'), source.root).find_or_self
+              end
+            end
+          end
+
+          def slug
+            @slug ||= SimpleSlugs::Slug.new(title).to_s
+          end
+
+          def title
+            @title ||= path_tokens.last.titleize
+          end
+
+          def permalink
+            @permalink ||= path_tokens.to_a[0..-2] << slug
+          end
+
+          def path_tokens
+            @path_tokens ||= source.to_s.gsub(/\.\w+$/, '').match(PERMALINK).to_a[1..-1]
+          end
+
+          def published_at
+            @published_at ||= DateTime.civil(*permalink[0..-2].map(&:to_i))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Adva
+  class Static
+    class Import
+      module Model
+        class Section < Base
+          class << self
+            def types
+              [Blog, Page]
+            end
+
+            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]
+          end
+
+          def record
+            @record ||= site.send(model.name.underscore.pluralize).find_or_initialize_by_path(path)
+          end
+
+          def site
+            @site ||= Site.new(source.root).record
+          end
+
+          def type
+            model.name
+          end
+
+          def name
+            @name ||= source.root? ? 'Home' : source.basename.titleize
+          end
+
+          def slug
+            @slug ||= source.root? ? SimpleSlugs::Slug.new(name) : super
+          end
+
+          def path
+            @path ||= source.root? ? slug : super
+          end
+
+          def loadable
+            @loadable ||= source.root? ? Source.new('index', source.root).find_or_self.full_path : source.full_path
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'site'
+
+module Adva
+  class Static
+    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
+
+          def attribute_names
+            @attribute_names ||= [:account, :host, :name, :title, :sections_attributes]
+          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)
+          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?
+            end
+          end
+
+          def loadable
+            @loadable ||= Source.new('site', source.root).find_or_self.full_path
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Adva
+  class Static
+    class Import
+      class Request
+        attr_reader :source, :record, :attributes
+
+        def initialize(source, record, attributes)
+          @source = source
+          @record = record
+          @attributes = attributes
+        end
+
+        def params
+          @params ||= begin
+            key = model_name.underscore.to_sym
+            if destroy?
+              params = { '_method' => 'delete', key => { :id => record.id } }
+            else
+              params = { model_name.underscore.to_sym => attributes }
+              params.merge!('_method' => 'put') if update?
+            end
+            stringify(params)
+          end
+        end
+
+        def path
+          controller.polymorphic_path(controller.resources)
+        end
+
+        def public_path
+          controller.public_url_for(controller.resources, :routing_type => :path)
+        end
+
+        def create?
+          !update? && !destroy?
+        end
+
+        def update?
+          record.persisted? && source.exist?
+        end
+
+        def destroy?
+          record.persisted? && !source.exist?
+        end
+
+        def controller
+          @controller ||= controller_name.constantize.new.tap do |controller|
+            controller.request = ActionDispatch::TestRequest.new
+            controller.params = params_for(controller)
+          end
+        end
+
+        protected
+
+          def section_ids
+            @section_ids ||= Section.types.map { |type| :"#{type.underscore}_id" }
+          end
+
+          def model_name
+            record.class.name
+          end
+
+          def controller_name
+            "Admin::#{model_name.pluralize}Controller"
+          end
+
+          def params_for(controller)
+            names = controller.send(:symbols_for_association_chain).dup
+            names.map! { |name| :"#{name}_id" }
+            names << :id unless record.new_record?
+
+            names.inject(:action => record.new_record? ? :index : :show) do |params, name|
+              # umm. admin blog routes use :blog_id, but Post has a section_id
+              value = attributes[section_ids.include?(name) ? :section_id : name].to_s
+              params.merge(name => value)
+            end
+          end
+
+          def stringify(object)
+            case object
+            when Hash
+              object.each { |key, value| object[key] = stringify(value) }
+            when Array
+              object.map! { |element| stringify(element) }
+            else
+              object.to_s
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+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
+          end
+        end
+
+        def <=>(other)
+          path == 'index' ? -1 : other.path == 'index' ? 1 : path <=> other.path
+        end
+      end
+    end
+  end
+end

data/lib/adva/static/rack.rb

@@ -0,0 +1,15 @@
+require 'adva'
+
+module Adva
+  class Static
+    module Rack
+      PURGE_HEADER = 'rack-cache.purge'
+      STORE_HEADER = 'rack-static.store'
+
+      autoload :Request, 'adva/static/rack/request'
+      autoload :Export,  'adva/static/rack/export'
+      autoload :Static,  'adva/static/rack/static'
+      autoload :Watch, 'adva/static/rack/watch'
+    end
+  end
+end