mill 0.16 → 0.18

data/lib/mill/site.rb

@@ -2,391 +2,290 @@ module Mill
 
   class Site
 
-    attr_accessor :input_dir
-    attr_accessor :output_dir
-    attr_accessor :site_rsync
-    attr_accessor :site_title
-    attr_accessor :site_uri
-    attr_accessor :site_email
-    attr_accessor :site_control_date
-    attr_accessor :html_version
-    attr_accessor :feed_resource
-    attr_accessor :sitemap_resource
-    attr_accessor :robots_resource
-    attr_accessor :shorten_uris
-    attr_accessor :make_feed
-    attr_accessor :make_sitemap
-    attr_accessor :make_robots
-    attr_accessor :allow_robots
-    attr_accessor :htpasswd_file
-    attr_accessor :navigator
-    attr_accessor :resource_classes
-    attr_accessor :redirects
-    attr_accessor :resources
-
-    DefaultResourceClasses = ObjectSpace.each_object(Class).select { |c| c < Resource }
-
-    def initialize(input_dir: 'content',
-                   output_dir: 'public_html',
-                   site_rsync: nil,
-                   site_title: nil,
-                   site_uri: 'http://localhost',
-                   site_email: nil,
-                   site_control_date: Date.today.to_s,
-                   html_version: :html4_transitional,
-                   shorten_uris: true,
-                   make_feed: true,
-                   make_sitemap: true,
-                   make_robots: true,
-                   allow_robots: true,
-                   htpasswd_file: nil,
-                   navigator: nil,
-                   google_site_verification: nil,
-                   resource_classes: [],
-                   redirects: {})
-
-      @input_dir = Path.new(input_dir)
-      @output_dir = Path.new(output_dir)
-      @site_rsync = site_rsync
-      @site_title = site_title
-      @site_uri = Addressable::URI.parse(site_uri)
-      @site_email = Addressable::URI.parse(site_email) if site_email
-      @site_control_date = Date.parse(site_control_date)
-      @html_version = html_version
-      @shorten_uris = shorten_uris
-      @make_feed = make_feed
-      @make_sitemap = make_sitemap
-      @make_robots = make_robots
-      @allow_robots = allow_robots
-      @htpasswd_file = htpasswd_file ? Path.new(htpasswd_file) : nil
-      @resource_classes = resource_classes
-      @navigator = navigator
-      @google_site_verification = google_site_verification
-      @redirects = redirects
-
-      @resources = {}
-      @resources_tree = Tree::TreeNode.new('')
-      build_file_types
-    end
-
-    def build_file_types
+    attr_accessor :config
+    attr_reader   :feed_resource
+    attr_reader   :sitemap_resource
+    attr_reader   :robots_resource
+    attr_reader   :redirects
+    attr_reader   :resources
+    attr_reader   :file_types
+
+    def self.load(dir=nil)
+      config = BaseConfig.make(dir: dir)
+      config = config.load_yaml(config.dir / ConfigFileName)
+      site_file = config.dir / config.code_dir / 'site.rb'
+      klass = load_site_class(site_file)
+      klass.new(config)
+    end
+
+    def self.load_site_class(site_file)
+      Kernel.load(site_file.expand_path.to_s) if site_file.exist?
+      site_classes = subclasses
+      if site_classes.length == 0
+        self
+      elsif site_classes.length > 1
+        raise Error, "More than one #{self.class} class defined"
+      else
+        site_classes.first
+      end
+    end
+
+    def initialize(config)
+      @config = config
+      @redirects = {}
+      @resources = Resources.new
+      make_file_types
+    end
+
+    def inspect
+      "<#{self.class}>"
+    end
+
+    def input_dir = @config.dir / @config.input_dir
+    def output_dir = @config.dir / @config.output_dir
+    def site_uri = @config.site_uri
+    def site_rsync = @config.site_rsync
+    def site_title = @config.site_title
+    def site_email = @config.site_email
+    def site_postal = @config.site_postal
+    def site_phone = @config.site_phone
+    def site_instagram = @config.site_instagram
+    def site_control_date = @config.site_control_date
+    def html_version = @config.html_version
+    def make_error? = @config.make_error
+    def make_feed? = @config.make_feed
+    def make_sitemap? = @config.make_sitemap
+    def make_robots? = @config.make_robots
+    def allow_robots? = @config.allow_robots
+
+    def make_file_types
       @file_types = {}
-      (DefaultResourceClasses + @resource_classes).each do |resource_class|
+      get_file_types(Resource)
+    end
+
+    def get_file_types(klass)
+      klass.subclasses.each do |resource_class|
         resource_class.const_get(:FileTypes).each do |type|
           @file_types[type] = resource_class
         end
+        get_file_types(resource_class)
       end
     end
 
     def add_resource(resource)
-      raise "Must assign resource to site" unless resource.site
-      @resources[resource.path] = resource
-      node = @resources_tree
-      resource.path.split('/').reject(&:empty?).each do |component|
-        node = node[component] || (node << Tree::TreeNode.new(component))
-      end
-      resource.node = node
-      node.content = resource
-      # ;;warn "added #{resource} as #{resource.path}"
+      # ;;warn "adding #{resource.class} as #{resource.path}"
+      resource.site = self
+      resource.load
+      @resources << resource
     end
 
     def find_resource(path)
-      path = path.path if path.kind_of?(Addressable::URI)
-      @resources[path] || @resources[path + '/']
+      @resources[path]
     end
 
-    def home_resource
-      find_resource('/')
+    def root_resource
+      @resources['/']
     end
 
     def tag_uri
       'tag:%s:' % [
         [
-          @site_uri.host.downcase,
-          @site_control_date
+          site_uri.host.downcase,
+          site_control_date
         ].join(','),
       ]
     end
 
     def feed_author_name
-      @site_title
+      site_title
     end
 
     def feed_author_uri
-      @site_uri
+      site_uri
     end
 
     def feed_author_email
-      @site_email
-    end
-
-    def select_resources(selector=nil, &block)
-      if block_given?
-        @resources.values.select(&block)
-      elsif selector.kind_of?(Class)
-        @resources.values.select { |r| r.kind_of?(selector) }
-      else
-        @resources.values.select(selector)
-      end
+      site_email
     end
 
     def feed_resources
-      public_resources.sort_by(&:date)
+      primary_resources
     end
 
-    def public_resources
-      select_resources(&:public?)
+    def sitemap_resources
+      primary_resources
     end
 
-    def redirect_resources
-      select_resources(&:redirect?)
-    end
-
-    def text_resources
-      select_resources(&:text?)
-    end
-
-    def make
-      build
-      save
-    end
-
-    def print_tree(node=nil, level=0)
-      node ||= @resources_tree
-      if node.is_root?
-        print '*'
-      else
-        print "\t" * level
-      end
-      print " #{node.name.inspect}"
-      print " <#{node.content&.path}>"
-      print " (#{node.children.length} children)" if node.has_children?
-      puts
-      node.children { |child| print_tree(child, level + 1) }
-    end
-
-    ListKeys = {
-      path:         :to_s,
-      input_file:   :to_s,
-      output_file:  :to_s,
-      date:         :to_s,
-      public:       :to_s,
-      class:        :to_s,
-      content:      proc { |r| r.content ? ('%s (%dKB)' % [r.content.class, (r.content.to_s.length / 1024.0).ceil]) : nil },
-      parent:       proc { |r| r.parent&.path },
-      siblings:     proc { |r| r.siblings.map(&:path) },
-      children:     proc { |r| r.children.map(&:path) },
-    }
-
-    def list
-      build
-      width = ListKeys.keys.map(&:length).max
-      select_resources.each do |resource|
-        ListKeys.each do |key, converter|
-          value = resource.send(key)
-          value = case converter
-          when nil
-            value
-          when Symbol
-            value.send(converter)
-          when Proc
-            converter.call(resource)
-          else
-            raise
-          end
-          print '%*s: ' % [width, key]
-          case value
-          when Array
-            if value.empty?
-              puts '-'
-            else
-              value.each_with_index do |v, i|
-                print '%*s  ' % [width, ''] if i > 0
-                puts (v.nil? ? '-' : v)
-              end
-            end
-          else
-            puts (value.nil? ? '-' : value)
-          end
-        end
-        puts
-      end
-      puts
+    def primary_resources
+      @resources.select(&:primary?).sort_by(&:date)
     end
 
     def build
-      import_resources
       load_resources
+      convert_resources
       build_resources
+      check
     end
 
-    def import_resources
+    def load_resources
       add_files
       add_redirects
-      add_google_site_verification if @google_site_verification
-      add_feed if @make_feed
-      add_sitemap if @make_sitemap
-      add_robots if @make_robots
-      add_htpasswd if @htpasswd_file
-    end
-
-    def load_resources
-      on_each_resource do |resource|
-        # ;;warn "#{resource.path}: loading"
-        resource.load
-      end
+      add_error if make_error?
+      add_feed if make_feed?
+      add_sitemap if make_sitemap?
+      add_robots if make_robots?
     end
 
     def build_resources
-      on_each_resource do |resource|
+      @resources.each do |resource|
         # ;;warn "#{resource.path}: building"
         resource.build
       end
     end
 
-    def save
-      clean
-      @output_dir.mkpath
-      on_each_resource do |resource|
-        # ;;warn "#{resource.path}: saving"
-        resource.save
+    def convert_resources
+      @resources.select { |r| r.respond_to?(:convert) }.each do |resource|
+        new_resource = resource.convert
+        @resources.delete(resource)
+        if new_resource
+          new_resource.load
+          add_resource(new_resource)
+        end
       end
     end
 
-    def clean
-      if @output_dir.exist?
-        @output_dir.children.reject { |p| p.basename.to_s == '.git' }.each do |path|
+    def save
+      if output_dir.exist?
+        output_dir.children.reject { |p| p.basename.to_s == '.git' }.each do |path|
           path.rm_rf
         end
+      else
+        output_dir.mkpath
+      end
+      @resources.each do |resource|
+        # ;;warn "#{resource.path}: saving"
+        resource.save
       end
     end
 
-    def check
-      build
-      checker = WebChecker.new(site_uri: @site_uri, site_dir: @output_dir)
-    end
-
-    def snapshot
-      @output_dir.chdir do
-        system('git',
-          'init') unless Path.new('.git').exist?
-        system('git',
-          'add',
-          '.')
-        system('git',
-          'commit',
-          '-a',
-          '-m',
-          'Update.')
+    def check(external: false)
+      build if @resources.empty?
+      @resources.of_class(Resource::Page).each do |resource|
+        resource.links.each do |link|
+          begin
+            check_uri(link, external: external)
+          rescue Error => e
+            warn "#{resource.path}: #{e}"
+          end
+        end
       end
     end
 
-    def diff
-      @output_dir.chdir do
-        system('git',
-          'diff')
-      end
+    def resource_class_for_file(file)
+      types = MIME::Types.type_for(file.to_s)
+      content_type = types.last&.content_type or raise Error, "Can't determine content type: #{file.to_s.inspect}"
+      resource_class_for_type(content_type) or raise Error, "Unknown file type: #{file.to_s.inspect} (#{types.join(', ')})"
     end
 
-    def upload
-      raise "site_rsync not defined" unless @site_rsync
-      system('rsync',
-        '--progress',
-        '--verbose',
-        '--archive',
-        # '--append-verify',
-        '--exclude=.git',
-        '--delete-after',
-        @output_dir.to_s,
-        @site_rsync)
-    end
-
-    def on_each_resource(&block)
-      @resources.values.each do |resource|
-        begin
-          yield(resource)
-        rescue Error => e
-          raise e, "#{resource.input_file || '-'} (#{resource.path}): #{e}"
-        end
-      end
+    def resource_class_for_type(type)
+      @file_types[type]
     end
 
     private
 
-    def resource_class_for_file(file)
-      type = MIME::Types.of(file.to_s).first
-      if type && (klass = @file_types[type.content_type])
-        klass
-      else
-        raise Error, "Unknown file type: #{file.to_s.inspect} (#{MIME::Types.of(file.to_s).join(', ')})"
-      end
-    end
-
     def add_files
-      raise Error, "Input directory not found: #{@input_dir}" unless @input_dir.exist?
-      @input_dir.find do |input_file|
+      raise Error, "Input directory not found: #{input_dir}" unless input_dir.exist?
+      input_dir.find do |input_file|
         if input_file.basename.to_s[0] == '.'
           Find.prune
+        elsif input_file.basename.to_s == "Icon\r"
+          # skip macOS garbage file
         elsif input_file.directory?
-          # skip
+          # skip directories
         else (klass = resource_class_for_file(input_file))
-          resource = klass.new(
-            input_file: input_file,
-            output_file: @output_dir / input_file.relative_to(@input_dir),
-            site: self)
+          resource = klass.new(input: input_file, path: '/' + input_file.relative_to(input_dir).to_s)
           add_resource(resource)
         end
       end
     end
 
+    def add_error
+      input = Simple::Builder.parse_html_document(
+        Kramdown::Document.new(
+          %Q{
+            Something went wrong.
+            The page you were looking for doesn’t exist or couldn’t be displayed.
+            Please try another option.
+          }.gsub(/\s+/, ' ').strip
+        ).to_html
+      )
+      klass = resource_class_for_type('text/html')
+      @error_resource = klass.new(
+        path: '/error.html',
+        title: 'Error',
+        primary: false,
+        input: input)
+      add_resource(@error_resource)
+    end
+
     def add_feed
-      @feed_resource = Resource::Feed.new(
-        output_file: @output_dir / 'feed.xml',
-        site: self)
+      @feed_resource = Resource::Feed.new(path: '/feed.xml')
       add_resource(@feed_resource)
     end
 
     def add_sitemap
-      @sitemap_resource = Resource::Sitemap.new(
-        output_file: @output_dir / 'sitemap.xml',
-        site: self)
+      @sitemap_resource = Resource::Sitemap.new(path: '/sitemap.xml')
       add_resource(@sitemap_resource)
     end
 
     def add_robots
-      @robots_resource = Resource::Robots.new(
-        output_file: @output_dir / 'robots.txt',
-        site: self)
+      @robots_resource = Resource::Robots.new(path: '/robots.txt')
       add_resource(@robots_resource)
     end
 
     def add_redirects
       if @redirects
         @redirects.each do |from, to|
-          output_file = @output_dir / Path.new(from).relative_to('/')
-          resource = Resource::Redirect.new(
-            output_file: output_file,
-            redirect_uri: to,
-            site: self)
+          resource = Resource::Redirect.new(path: Path.new(from).add_extension('.redirect').to_s, redirect_uri: to)
           add_resource(resource)
         end
       end
     end
 
-    def add_google_site_verification
-      resource = Resource::GoogleSiteVerification.new(
-        output_file: (@output_dir / @google_site_verification).add_extension('.html'),
-        key: @google_site_verification,
-        site: self)
-      add_resource(resource)
+    def check_uri(uri, external: false)
+      if uri.relative?
+        unless find_resource(uri.path)
+          raise Error, "NOT FOUND: #{uri}"
+        end
+      elsif external
+        if uri.scheme.start_with?('http')
+          # warn "checking external URI: #{uri}"
+          begin
+            check_external_uri(uri)
+          rescue => e
+            raise Error, "external URI: #{uri}: #{e}"
+          end
+        else
+          warn "Don't know how to check URI: #{uri}"
+        end
+      end
     end
 
-    def add_htpasswd
-      resource = Resource.new(
-        input_file: @htpasswd_file,
-        output_file: @output_dir / '.htpasswd',
-        site: self)
-      add_resource(resource)
+    def check_external_uri(uri)
+      response = HTTP.timeout(3).get(uri)
+      case response.code
+      when 200...300
+        # ignore
+      when 300...400
+        redirect_uri = Addressable::URI.parse(response.headers['Location'])
+        check_external_uri(uri + redirect_uri)
+      when 404
+        raise Error, "URI not found: #{uri}"
+      when 999
+        # ignore bogus LinkedIn status
+      else
+        raise Error, "Bad status from #{uri}: #{response.inspect}"
+      end
     end
 
   end

data/lib/mill.rb

@@ -1,30 +1,48 @@
 require 'addressable'
+require 'hashstruct'
+require 'http'
 require 'image_size'
 require 'kramdown'
 require 'mime/types'
 require 'nokogiri'
 require 'path'
-require 'pp'
-# require 'pry' rescue nil
 require 'RedCloth'
-require 'rubypants'
+require 'run-command'
 require 'sassc'
+require 'set_params'
+require 'simple-builder'
+require 'simple-command-parser'
+require 'simple-configurator'
+require 'simple-printer'
 require 'time'
 require 'tree'
-require 'web-checker'
 
+class Class
+
+  def self.subclasses
+    constants
+      .map { |c| const_get(c) }
+      .select { |c| c.kind_of?(Class) }
+  end
+
+end
+
+require 'mill/command'
+require 'mill/config'
 require 'mill/error'
-require 'mill/html_helpers'
-require 'mill/navigator'
 require 'mill/resource'
+require 'mill/resources'
 require 'mill/resources/blob'
 require 'mill/resources/feed'
-require 'mill/resources/google_site_verification'
 require 'mill/resources/image'
+require 'mill/resources/markup'
+require 'mill/resources/markdown'
+require 'mill/resources/page'
 require 'mill/resources/redirect'
 require 'mill/resources/robots'
 require 'mill/resources/sitemap'
 require 'mill/resources/stylesheet'
-require 'mill/resources/text'
+require 'mill/resources/textile'
 require 'mill/site'
-require 'mill/version'
+
+Path.new(__FILE__).dirname.glob('mill/commands/*.rb').each { |p| require p }