adva-static 0.0.1

data/lib/adva/static/export/page.rb

@@ -0,0 +1,45 @@
+require 'rack'
+
+module Adva
+  class Static
+    class Export
+      class Page
+        URL_ATTRIBUTES = {
+          '//a[@href]' => 'href',
+          '//script[@src]' => 'src',
+          '//link[@rel="stylesheet"]' => 'href'
+        }
+
+        attr_reader :url, :response
+
+        def initialize(url, response)
+          @url      = Path.new(url)
+          @response = response
+        end
+
+        def urls
+          URL_ATTRIBUTES.inject([]) do |urls, (xpath, name)|
+            urls += dom.xpath(xpath).map { |node| Path.new(node.attributes[name]) }
+          end
+        end
+
+        def body
+          @body ||= case response
+          when ActionDispatch::Response
+            response.body
+          when ::Rack::File
+            File.read(response.path)
+          else
+            response.to_s
+          end
+        end
+
+        protected
+
+          def dom
+            @dom ||= Nokogiri::HTML(body)
+          end
+      end
+    end
+  end
+end

data/lib/adva/static/export/path.rb

@@ -0,0 +1,49 @@
+require 'uri'
+
+module Adva
+  class Static
+    class Export
+      class Path < String
+        attr_reader :host
+
+        def initialize(path)
+          @host = URI.parse(path.to_s).host rescue 'invalid.host'
+          path  = normalize_path(path)
+          super
+        end
+
+        def filename
+          @filename ||= normalize_filename(self)
+        end
+
+        def extname
+          @extname ||= File.extname(self)
+        end
+
+        def html?
+          extname.blank? || extname == '.html'
+        end
+
+        def remote?
+          host.present?
+        end
+
+        protected
+
+          def normalize_path(path)
+            path = URI.parse(path.to_s).path || '/' rescue '/'        # extract path
+            path = path[0..-2] if path[-1, 1] == '/'                  # remove trailing slash
+            path = "/#{path}" unless path[0, 1] == '/'                # add leading slash
+            path
+          end
+
+          def normalize_filename(path)
+            path = path[1..-1] if path[0, 1] == '/'                   # remove leading slash
+            path = 'index' if path.empty?                             # use 'index' instead of empty paths
+            path = (html? ? "#{path.gsub(extname, '')}.html" : path)  # add .html extension if necessary
+            path
+          end
+      end
+    end
+  end
+end

data/lib/adva/static/export/queue.rb

@@ -0,0 +1,27 @@
+module Adva
+  class Static
+    class Export
+      class Queue < Array
+        def push(*elements)
+          elements = Array(elements).flatten.uniq
+          elements.reject! { |element| seen?(element) }
+          seen(elements)
+          super
+        end
+      
+        def seen?(element)
+          log.include?(element)
+        end
+      
+        def seen(elements)
+          @log = log.concat(elements)
+          log.uniq!
+        end
+      
+        def log
+          @log ||= []
+        end
+      end
+    end
+  end
+end

data/lib/adva/static/export/store.rb

@@ -0,0 +1,30 @@
+require 'fileutils'
+
+module Adva
+  class Static
+    class Export
+      class Store
+        attr_reader :dir
+
+        def initialize(dir)
+          @dir = Pathname.new(dir.to_s)
+          FileUtils.mkdir_p(dir)
+        end
+
+        def exists?(path)
+          File.exists?(dir.join(path.filename))
+        end
+
+        def write(path, body)
+          path = dir.join(path.filename)
+          FileUtils.mkdir_p(File.dirname(path))
+          File.open(path, 'w+') { |f| f.write(body) }
+        end
+      
+        def purge(path)
+          dir.join(path.filename).delete rescue Errno::ENOENT
+        end
+      end
+    end
+  end
+end

data/lib/adva/static/export/templates/config.ru

@@ -0,0 +1,14 @@
+Dir.chdir('..') until File.exists?('config/environment.rb')
+
+require 'config/environment.rb'
+
+Rails::Application.configure do
+  ActionController::Base.allow_forgery_protection = false
+end
+
+use Adva::Static::Rack::Watch
+use Adva::Static::Rack::Export
+use Adva::Static::Rack::Static, ::File.expand_path('../export', __FILE__)
+
+puts 'listening.'
+run Rails.application

data/lib/adva/static/export.rb

@@ -0,0 +1,104 @@
+require 'nokogiri'
+require 'uri'
+require 'benchmark'
+
+module Adva
+  class Static
+    class Export
+      autoload :Page,   'adva/static/export/page'
+      autoload :Path,   'adva/static/export/path'
+      autoload :Queue,  'adva/static/export/queue'
+      autoload :Store,  'adva/static/export/store'
+
+      attr_reader :app, :queue, :store, :options
+
+      DEFAULT_OPTIONS = {
+        :source => "#{Dir.pwd}/public",
+        :target => "#{Dir.pwd}/export"
+      }
+
+      def initialize(app, options = {})
+        @options = options.reverse_merge!(DEFAULT_OPTIONS)
+
+        @app   = app
+        @store = Store.new(target)
+        @queue = Queue.new
+
+        queue.push(options[:queue] || Path.new('/'))
+
+        FileUtils.rm_r(Dir[target.join('*')])
+      end
+
+      def run
+        configure
+        copy_assets
+        process(queue.shift) until queue.empty?
+      end
+
+      protected
+
+        def source
+          @source ||= Pathname.new(options[:source])
+        end
+
+        def target
+          @target ||= Pathname.new(options[:target])
+        end
+
+        def copy_assets
+          %w(images javascripts stylesheets).each do |dir|
+            FileUtils.cp_r(source.join(dir), target.join(dir)) if source.join(dir).exist?
+          end
+        end
+
+        def process(path)
+          if page = get(path)
+            store.write(path, page.body)
+            enqueue_urls(page) if path.html?
+          end
+        end
+
+        def get(path)
+          result = nil
+          bench = Benchmark.measure do
+            result = app.call(env_for(path))
+            result = follow_redirects(result)
+          end
+
+          status, headers, response = result
+          if status == 200
+            Adva.out.puts "#{bench.total.to_s[0..3]}s: exporting #{path}"
+            Page.new(path, headers['X-Sendfile'] ? File.read(headers['X-Sendfile']) : response)
+          else
+            Adva.out.puts "can not export #{path} (status: #{status})"
+          end
+        end
+
+        def follow_redirects(response)
+          response = app.call(env_for(response[1]['Location'])) while redirect?(response[0])
+          response
+        end
+
+        def redirect?(status)
+          status == 301
+        end
+
+        def env_for(path)
+          site = Site.first || raise('could not find any site') # TODO make this a cmd line arg or options
+          name, port = site.host.split(':')
+          ::Rack::MockRequest.env_for(path).merge('SERVER_NAME' => name,'SERVER_PORT' => port || '80')
+        end
+
+        def enqueue_urls(page)
+          queue.push(page.urls.reject { |path| path.remote? || store.exists?(path) }.uniq)
+        end
+
+        def configure
+          config = Path.new('config.ru')
+          unless store.exists?(config)
+            store.write(config, File.read(File.expand_path('../export/templates/config.ru', __FILE__)))
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Adva
+  class Static
+    class Import
+      module Format
+        def self.for(path)
+          name = File.extname(path).gsub('.', '').camelize
+          const_get(name).new(path) if name.present?
+        end
+
+        class Base
+          attr_reader :path
+
+          def initialize(path)
+            @path = path
+          end
+
+          def load(target)
+            data.each do |name, value|
+              define_attribute(target, name) if define_attribute?(target, name)
+              target.instance_variable_set(:"@#{name}", value)
+            end if data.is_a?(Hash)
+          end
+
+          def define_attribute?(target, name)
+            !target.attribute_name?(name) && target.column_name?(name)
+          end
+
+          def define_attribute(target, name)
+            target.attribute_names << name
+            target.attribute_names.uniq!
+            target.class.send(:attr_reader, name) unless target.respond_to?(name)
+          end
+        end
+
+        class Yml < Base
+          def data
+            @data ||= YAML.load_file(path)
+          end
+        end
+
+        class Jekyll < Base
+          def data
+            @data ||= begin
+              file =~ /^(---\s*\n.*?\n?)^---\s*$\n?(.*)/m
+              data = YAML.load($1) rescue {}
+              data.merge!(:body => $2) if $2
+              data
+            end
+          end
+
+          def file
+            @file ||= File.read(path)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'core_ext/ruby/array/flatten_once'
+
+module Adva
+  class Static
+    class Import
+      module Model
+        class Base
+          attr_reader :source, :attribute_names
+
+          def initialize(source)
+            @source = source
+            load
+          end
+
+          def attributes
+            attributes = attribute_names.map { |name| [name, self.send(name)] unless self.send(name).nil? }
+            attributes = Hash[*attributes.compact.flatten_once]
+            record && record.id ? attributes.merge(:id => record.id.to_s) : attributes
+          end
+
+          def attribute_name?(name)
+            attribute_names.include?(name.to_sym)
+          end
+
+          def column_name?(name)
+            model.column_names.include?(name.to_s)
+          end
+
+          def updated_record
+            record.tap { |record| record.attributes = attributes }
+          end
+
+          def model
+            self.class.name.demodulize.constantize
+          end
+
+          def site_id
+            site.id.to_s
+          end
+
+          def slug
+            source.basename
+          end
+
+          def path
+            source.path
+          end
+
+          def body
+            @body || ''
+          end
+
+          def updated_at
+            source.mtime
+          end
+
+          def loadable
+            @loadable ||= source.full_path
+          end
+
+          def load
+            if loadable.exist?
+              format = Format.for(loadable) and format.load(self)
+            end
+          end
+
+          def ==(other)
+            source == other
+          end
+
+          def <=>(other)
+            source <=> other.source
+          end
+        end
+      end
+    end
+  end
+end

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,33 @@
+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 + [:article_attributes]
+          end
+
+          def article_attributes
+            attributes = { :title => name, :body => body }
+            record.persisted? ? attributes.merge(:id => record.article.id.to_s) : attributes
+          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, :created_at] # TODO created_at should be 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 created_at
+            @created_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/model.rb

@@ -0,0 +1,21 @@
+module Adva
+  class Static
+    class Import
+      module Model
+        autoload :Base,    'adva/static/import/model/base'
+        autoload :Blog,    'adva/static/import/model/blog'
+        autoload :Page,    'adva/static/import/model/page'
+        autoload :Post,    'adva/static/import/model/post'
+        autoload :Section, 'adva/static/import/model/section'
+        autoload :Site,    'adva/static/import/model/site'
+
+        class << self
+          def recognize(sources)
+            types = [Site, Post, Section]
+            types.map { |type| type.recognize(sources) }.flatten.compact.sort
+          end
+        end
+      end
+    end
+  end
+end