adva-static 0.0.2 → 0.0.3

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

@@ -1,92 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/rack/export.rb

@@ -1,59 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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/setup.rb

@@ -1,68 +0,0 @@
-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