adva-static 0.0.1

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/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/rack/export.rb

@@ -0,0 +1,59 @@
+require 'fileutils'
+
+module Adva
+  class Static
+    module Rack
+      class Export
+        include Request
+
+        attr_reader :app, :target, :store
+
+        def initialize(app, options = {})
+          @app = app
+          @target = Pathname.new(options[:target] || File.expand_path('./export'))
+          @store  = Adva::Static::Export::Store.new(target)
+        end
+
+        def call(env)
+          path = env['PATH_INFO'].dup # gets modified by routing_filter
+          app.call(env).tap do |status, headers, response|
+            export(path, response) if export?(env, status)
+            if headers.key?(PURGE_HEADER)
+              paths = normalize_paths(headers[PURGE_HEADER])
+              paths.each do |path|
+                purge(path)
+                request(path)
+              end
+            end
+          end
+        end
+
+        protected
+
+          def export?(env, status)
+            env[STORE_HEADER].present? and status == 200
+          end
+
+          def export(path, response)
+            page = Adva::Static::Export::Page.new(path, response)
+            Adva.out.puts "  storing #{page.url.filename}"
+            store.write(page.url, page.body)
+          end
+
+          def purge(path)
+            Adva.out.puts "  purging #{path}"
+            store.purge(Adva::Static::Export::Path.new(path))
+          end
+
+          def request(path)
+            super('GET', Adva::Static::Export::Path.new(path), STORE_HEADER => true)
+          end
+
+          def normalize_paths(paths)
+            paths = paths.split("\n") if paths.is_a?(String)
+            Array(paths)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'rack/utils'
+
+module Adva
+  class Static
+    module Rack
+      module Request
+        protected
+          def request(method, path, params = {})
+            Adva.out.puts "  #{params['_method'] ? params['_method'].upcase : method} #{path} "
+            call(env_for(method, path, params)).tap do |status, headers, response|
+              Adva.out.puts "  => #{status} " + (status == 302 ? "(Location: #{headers['Location']})" : '')
+              Adva.out.puts response if status == 500
+            end
+          end
+
+          def env_for(method, path, params)
+            ::Rack::MockRequest.env_for("http://#{site.host}#{path}", :method => method,
+              :input => ::Rack::Utils.build_nested_query(params),
+              'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
+              'HTTP_AUTHORIZATION' => 'Basic ' + ["#{username}:#{password}"].pack('m*'),
+              STORE_HEADER => params[STORE_HEADER]
+            )
+          end
+
+          def username
+            'admin@admin.org' # TODO read from conf/auth.yml or something
+          end
+
+          def password
+            'admin!'
+          end
+
+          def site
+            @site ||= Site.first || raise('could not find any site') # FIXME
+          end
+      end
+    end
+  end
+end

data/lib/adva/static/rack/static.rb

@@ -0,0 +1,40 @@
+require 'rack/utils'
+
+module Adva
+  class Static
+    module Rack
+      class Static < ::Rack::File
+        attr_reader :app, :root
+
+        def initialize(app, root)
+          @app  = app
+          @root = root
+          Adva.out.puts "serving from #{root}"
+        end
+
+        def call(env)
+          if get?(env) && path = static(env)
+            super(env.merge('PATH_INFO' => path))
+          else
+            app.call(env)
+          end
+        end
+
+        protected
+
+          def static(env)
+            path = env['PATH_INFO'].chomp('/')
+            [path, "#{path}.html", "#{path}/index.html"].detect { |path| file?(path) }
+          end
+
+          def file?(path)
+            File.file?(File.join(root, ::Rack::Utils.unescape(path)))
+          end
+
+          def get?(env)
+            env['REQUEST_METHOD'] == 'GET'
+          end
+      end
+    end
+  end
+end

data/lib/adva/static/rack/watch.rb

@@ -0,0 +1,88 @@
+require 'watchr'
+
+module Adva
+  class Static
+    module Rack
+      class Watch
+        autoload :Handler, 'adva/static/watch/handler'
+
+        include Request
+
+        attr_reader :app, :dir, :watch
+
+        delegate :call, :to => :app
+
+        def initialize(app, options = {}, &block)
+          @app = app
+          @dir = Pathname.new(options[:dir] || File.expand_path('import'))
+          dir.mkpath
+          run!
+        end
+
+        def update(path, event_type = nil)
+          Adva.out.puts "\n#{event_type}: #{path}"
+          import  = Adva::Static::Import.new(:source => dir)
+          request = import.request_for(path)
+          status, headers, response = self.request('POST', request.path, request.params)
+          get(path) if !request.destroy? && status == 302
+        rescue Exception => e
+          Adva.out.puts e.message
+          e.backtrace.each { |line| puts Adva.out.line }
+        end
+
+        def get(path)
+          import  = Adva::Static::Import.new(:source => dir)
+          request = import.request_for(path)
+          self.request('GET', request.public_path, STORE_HEADER => true)
+        rescue Exception => e
+          Adva.out.puts e.message
+          e.backtrace.each { |line| Adva.out.puts line }
+        end
+
+        protected
+
+          def run!
+            @watch = fork { watch!(Adva.out) }
+            at_exit { kill_watch }
+          end
+
+          def watch!(out)
+            Adva.out.puts "watching #{dir} for changes"
+            Dir.chdir(dir)
+            handler.listen
+          rescue SignalException, SystemExit
+          rescue Exception => e
+            p e
+            e.backtrace.each { |line| puts line }
+          end
+
+          def trap_interrupt
+            Signal.trap('INT') do
+              if Time.now - @interrupt < 1
+                exit
+              else
+                STDERR.puts "\nReloading watched paths ... interrupt again to exit."
+                handler.refresh(watched_paths)
+              end
+              @interrupt = Time.now
+            end
+            @interrupt = Time.now
+          end
+
+          def handler
+            @handler ||= Adva::Static::Watch::Handler.new(self, dir.join("**/*.{#{Import::Source::TYPES.join(',')}}"))
+          end
+
+          def kill_watch
+            Process.kill('TERM', watch)
+          end
+
+          def watched_paths
+            paths = Dir[dir.join('**/*')].map {|path| Pathname(path).expand_path }
+            paths << Pathname.new(__FILE__) if paths.empty?
+            paths
+          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

data/lib/adva/static/setup.rb

@@ -0,0 +1,68 @@
+require 'core_ext/ruby/kernel/silence_stream'
+
+module Adva
+  class Static
+    class Setup
+      attr_reader :app, :root, :source, :target, :host, :title, :remote
+
+      def initialize(options)
+        @app    = options[:app] || Rails.application
+        @root   = Pathname.new(options[:root] || Dir.pwd)
+        @source = root.join(options[:source]  || 'import')
+        @target = root.join(options[:target]  || 'export')
+        @remote = options[:remote]
+        @host   = options[:host]  || 'example.org'
+        @title  = options[:title] || host
+        
+        Adva.out = StringIO.new('')
+      end
+
+      def run
+        setup_directories
+        initial_import_and_export
+        setup_source_repository
+        setup_export_repository
+      end
+
+      def setup_directories
+        source.mkdir rescue Errno::EEXIST
+        target.mkdir rescue Errno::EEXIST
+        site = source.join('site.yml')
+        File.open(site, 'w+') { |f| f.write(YAML.dump(:host => host, :title => title)) } unless site.exist?
+      end
+
+      def initial_import_and_export
+        Import.new(:source => source).run
+        Export.new(app, :target => target).run
+      end
+      
+      def setup_source_repository
+        root.join('.gitignore').rmtree rescue Errno::ENOENT
+        root.join('.git').rmtree rescue Errno::ENOENT
+        
+        File.open(root.join('.gitignore'), 'w+') { |f| f.write('export') }
+        
+        Dir.chdir(root) do
+          `git init`
+          `git add .`
+          `git commit -am '#{host} source'`
+          `git branch source`
+          `git checkout --quiet source`
+          `git branch -D master`
+          `git remote add origin #{remote} -t source` if remote
+        end
+      end
+      
+      def setup_export_repository
+        root.join('export/.git').rmtree rescue Errno::ENOENT
+
+        Dir.chdir(target) do
+          `git init`
+          `git add .`
+          `git commit -am '#{host} export'`
+          `git remote add origin #{remote} -t master` if remote
+        end
+      end
+    end
+  end
+end

data/lib/adva/static/watch/handler.rb

@@ -0,0 +1,57 @@
+require 'observer'
+require 'watchr'
+require 'watchr/event_handlers/portable'
+
+module Adva
+  class Static
+    module Watch
+      class Handler
+        include Observable
+
+        def initialize(observable, pattern)
+          add_observer(observable)
+          @pattern = pattern
+          @current = Dir[pattern]
+          @mtime   = Time.now
+        end
+
+        def listen
+          loop { trigger; sleep(0.5) }
+        end
+
+        def trigger
+          events.each do |path, event|
+            changed(true)
+            notify_observers(path, event)
+          end
+        end
+
+        protected
+
+          def events
+            @last    = @current.dup
+            @current = Dir[@pattern]
+            deleted + created + modified
+          end
+
+          def modified
+            (@current & @last).each do |path|
+              mtime = File.mtime(path)
+              if mtime > @mtime
+                @mtime = mtime
+                return [[path, :modified]]
+              end
+            end && []
+          end
+
+          def created
+            (@current - @last).map { |path| [path, :created] }
+          end
+
+          def deleted
+            (@last - @current).map { |path| [path, :deleted] }
+          end
+      end
+    end
+  end
+end

data/lib/adva/static/watch.rb

@@ -0,0 +1,7 @@
+module Adva
+  class Static
+    module Watch
+      autoload :Handler, 'adva/static/watch/handler'
+    end
+  end
+end

data/lib/adva/static.rb

@@ -0,0 +1,13 @@
+require 'adva'
+
+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/tasks/static.rb

@@ -0,0 +1,73 @@
+require 'thor'
+require 'thor/group'
+require 'patches/thor/core_ext/hash'
+require 'patches/thor/group/symbolized_options'
+
+module Adva
+  module Tasks
+    class Static
+      class Setup < Thor::Group
+        namespace 'adva:static:setup'
+        desc 'Setup a static version of your site'
+        class_option :source, :required => false, :banner => 'source directory (defaults to import)'
+        class_option :target, :required => false, :banner => 'source directory (defaults to export)'
+        class_option :host,   :required => false, :banner => 'hostname of your site (defaults to example.org)'
+        class_option :title,  :required => false, :banner => 'title of your site (defaults to the hostname)'
+        class_option :remote, :required => false, :banner => 'github repository url (defaults to none)'
+
+        def export
+          require 'config/environment'
+          Adva::Static::Setup.new(symbolized_options).run
+        end
+      end
+
+      class Import < Thor::Group
+        namespace 'adva:static:import'
+        desc 'Import a site from a directory'
+        class_option :source, :required => false
+
+        def import
+          require 'config/environment'
+          Adva::Static::Import.new(symbolized_options).run
+        end
+      end
+
+      class Export < Thor::Group
+        namespace 'adva:static:export'
+        desc 'Export a static version of a site'
+        class_option :target, :required => false
+
+        def export
+          require 'config/environment'
+          Adva::Static::Export.new(Rails.application, symbolized_options).run
+        end
+      end
+
+      class Update < Thor::Group
+        namespace 'adva:static:update'
+        desc 'Import and export a static version of a site'
+        class_option :source, :required => false
+        class_option :target, :required => false
+
+        def export
+          require 'config/environment'
+          Adva::Static::Import.new(symbolized_options).run
+          Adva::Static::Export.new(Rails.application, symbolized_options).run
+        end
+      end
+
+      class Server < Thor::Group
+        namespace 'adva:static:server'
+        desc 'Start the adva:static server and watcher'
+        class_option :root, :required => false, :default => 'export'
+
+        def server
+          ARGV.shift
+          Dir.chdir(symbolized_options[:root])
+          require "rack"
+          ::Rack::Server.start
+        end
+      end
+    end
+  end
+end

data/lib/adva-static.rb

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