adva-static 0.0.2 → 0.0.3

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

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

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

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

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

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

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

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

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

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

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