adva-static 0.0.3 → 0.0.4

data/lib/adva-static.rb

@@ -0,0 +1 @@
+require 'adva/static'

data/lib/adva/static.rb

@@ -0,0 +1,13 @@
+require 'adva/core'
+
+module Adva
+  class Static < ::Rails::Engine
+    autoload :Export, 'adva/static/export'
+    autoload :Import, 'adva/static/import'
+    autoload :Watch,  'adva/static/watch'
+    autoload :Rack,   'adva/static/rack'
+    autoload :Setup,  'adva/static/setup'
+
+    include Adva::Engine
+  end
+end

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')
+          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/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/import.rb

@@ -0,0 +1,42 @@
+module Adva
+  class Static
+    class Import
+      autoload :Format,  'adva/static/import/format'
+      autoload :Model,   'adva/static/import/model'
+      autoload :Request, 'adva/static/import/request'
+      autoload :Source,  'adva/static/import/source'
+
+      attr_reader :root
+
+      def initialize(options = {})
+        @root = Pathname.new(File.expand_path(options[:source] || 'import'))
+      end
+
+      def run
+        Adva.out.puts "importing from #{root}"
+        Account.all.each(&:destroy)
+        Model::Site.new(root).updated_record.save!
+      end
+
+      def import(path)
+        model = recognize(path).first
+        model.updated_record.save! if model
+      end
+
+      def request_for(path)
+        model = recognize(path).first
+        Request.new(model.source, model.record, model.attributes)
+      end
+
+      protected
+
+        def source(path)
+          Source.new(path, root)
+        end
+
+        def recognize(path)
+          Model.recognize([source(path)])
+        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.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

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