adva-static 0.0.9 → 0.0.11

data/lib/adva/static.rb

@@ -1,12 +1,15 @@
 require 'adva/core'
+require 'adva/blog'
+require 'adva/cache'
+require 'adva/categories'
+require 'adva/markup'
 
 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'
+    autoload :Server, 'adva/static/server'
 
     include Adva::Engine
   end

data/lib/adva/static/export.rb

@@ -28,7 +28,7 @@ module Adva
         roots = config[:roots] || %w(/)
         queue.push(*roots.map { |path| Path.new(path) })
 
-        FileUtils.rm_r(Dir[target.join('*')])
+        FileUtils.rm_r(Dir[target.join('*')] - [target.join('config.ru').to_s])
       end
 
       def run

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

@@ -20,11 +20,11 @@ module Adva
           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
+end

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

@@ -1,14 +1,38 @@
-Dir.chdir('..') until File.exists?('config/environment.rb')
+# This config.ru file simply serves static files in the format exported by
+# adva-static. I.e. you can use it (e.g.) to deploy exported html files to
+# Heroku.
 
-require 'config/environment.rb'
+class Static < ::Rack::File
+  attr_reader :app, :root
 
-Rails::Application.configure do
-  ActionController::Base.allow_forgery_protection = false
-end
+  def initialize(app, root)
+    @app  = app
+    @root = root
+  end
+
+  def call(env)
+    if get?(env) && path = static(env)
+      super(env.merge('PATH_INFO' => path))
+    else
+      app.call(env)
+    end
+  end
+
+  protected
 
-use Adva::Static::Rack::Watch
-use Adva::Static::Rack::Export
-use Adva::Static::Rack::Static, ::File.expand_path('../export', __FILE__)
+    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
 
-puts 'listening.'
-run Rails.application
+use Static, ::File.expand_path('..', __FILE__)
+run lambda { [404, { 'content-type' => 'text/html' }, '<h1>404 Not found.</h1>'] }

data/lib/adva/static/import.rb

@@ -9,22 +9,23 @@ module Adva
       attr_reader :root
 
       def initialize(options = {})
-        @root = Pathname.new(File.expand_path(options[:source] || 'import'))
+        @root = Source::Path.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!
+        Category.delete_all
+        Model::Site.new(root).update!
       end
 
       def import(path)
-        model = recognize(path).first
-        model.updated_record.save! if model
+        model = recognize(path)
+        model.update! if model
       end
 
       def request_for(path)
-        model = recognize(path).first
+        model = recognize(path)
         Request.new(model.source, model.record, model.attributes)
       end
 
@@ -35,7 +36,13 @@ module Adva
         end
 
         def recognize(path)
-          Model.recognize([source(path)])
+          Model.build(Source.recognize([normalize_path(path)]).first)
+        end
+
+        def normalize_path(path)
+          path.gsub!(root.to_s, '')
+          path.gsub!(/^\//, '')
+          root.join(path)
         end
     end
   end

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

@@ -1,3 +1,5 @@
+require 'hashr'
+
 module Adva
   class Static
     class Import
@@ -14,42 +16,36 @@ module Adva
             @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
+          # 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)
+          def read
+            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)
+          def read
+            File.read(path) =~ /^(---\s*\n.*?\n?)^---\s*$\n?(.*)/m
+            data = YAML.load($1) rescue {}
+            data.merge!(:body => $2) if $2
+            data
           end
         end
       end

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

@@ -2,20 +2,19 @@ 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'
+        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
+          def build(source, *args)
+            const_get(source.model_name).new(source, *args)
           end
         end
       end
     end
   end
-end
+end

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

@@ -8,69 +8,46 @@ module Adva
           attr_reader :source, :attribute_names
 
           def initialize(source)
-            @source = source
-            load
+            @source = source.is_a?(Source::Base) ? source : Source.build(model_name, source)
           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)
+          def update!
+            updated_record.save!
           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
+          def attributes
+            attributes = attribute_names.map { |name| [name, attribute_value(name)] if attribute_value(name) } # attribute?(name)
+            attributes = Hashr.new(Hash[*attributes.compact.flatten_once])
+            record && record.id ? attributes.merge(:id => record.id.to_s) : attributes
           end
 
-          def body
-            @body || ''
+          def attribute_names
+            source.data.keys
           end
 
-          def updated_at
-            source.mtime
+          def attribute_value(name)
+            respond_to?(name) ? self.send(name) : source.data.send(name)
           end
 
-          def loadable
-            @loadable ||= source.full_path
+          def attribute?(name)
+            source.data.key?(name) || respond_to?(name)
           end
 
-          def load
-            if loadable.exist?
-              format = Format.for(loadable) and format.load(self)
-            end
+          def model
+            model_name.constantize
           end
 
-          def ==(other)
-            source == other
+          def model_name
+            @model_name ||= self.class.name.demodulize
           end
 
-          def <=>(other)
-            source <=> other.source
-          end
+          # def updated_at
+          #   source.mtime
+          # end
         end
       end
     end

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

@@ -3,28 +3,22 @@ module Adva
     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
+          def update!
+            super
+            categories.each { |category| category.save! }
+            posts.each { |post| post.update! }
           end
 
           def attribute_names
-            @attribute_names ||= super + [:posts_attributes]
+            @attribute_names ||= super - [:categories, :posts]
+          end
+
+          def categories
+            @categories ||= source.categories.map { |category| Category.new(:name => category, :section => record) }
           end
 
-          def posts_attributes
-            Post.recognize(source.files).map(&:attributes)
+          def posts
+            @posts ||= source.posts.map { |post| Post.new(post, self) }
           end
         end
       end

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

@@ -3,23 +3,8 @@ module Adva
     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]
+            @attribute_names ||= super | [:body]
           end
         end
       end

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

@@ -3,73 +3,46 @@ module Adva
     class Import
       module Model
         class Post < Base
-          PERMALINK = %r((?:^|/)(\d{4})(?:\-|\/)(\d{1,2})(?:\-|\/)(\d{1,2})(?:\-|\/)(.*)$)
+          delegate :permalink, :published_at, :to => :source
 
-          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
+          attr_reader :section
 
-            def permalink?(path)
-              path.to_s =~ PERMALINK
-            end
-
-            def strip_permalink(source)
-              Source.new(source.to_s.gsub(Post::PERMALINK, ''), source.root)
-            end
+          def initialize(source, section = nil)
+            super(source)
+            @section = section
           end
 
-          def attribute_names
-            @attribute_names ||= [:site_id, :section_id, :title, :body, :published_at]
+          def update!
+            super
+            record.update_attributes!(:categories => categories)
           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
+            @record ||= ::Post.by_permalink(*permalink).first || ::Post.new
           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
+          def attribute_names
+            @attribute_names ||= (super | [:site_id, :section_id, :title, :body, :slug, :published_at, :filter]) - [:categories]
           end
 
-          def slug
-            @slug ||= SimpleSlugs::Slug.new(title).to_s
+          def site
+            section.try(:site)
           end
 
-          def title
-            @title ||= path_tokens.last.titleize
+          def site_id
+            site ? site.record.id.to_s : nil
           end
 
-          def permalink
-            @permalink ||= path_tokens.to_a[0..-2] << slug
+          def section
+            @section ||= Section.new(source.strip_permalink)
           end
 
-          def path_tokens
-            @path_tokens ||= source.to_s.gsub(/\.\w+$/, '').match(PERMALINK).to_a[1..-1]
+          def section_id
+            section ? section.record.id.to_s : nil
           end
 
-          def published_at
-            @published_at ||= DateTime.civil(*permalink[0..-2].map(&:to_i))
+          def categories
+            @categories ||= source.data.categories.map { |name| Category.find_or_create_by_name(name, :section_id => section.record.id) }
           end
         end
       end