retter 0.2.5 → 1.0.0.pre

data/lib/retter/binder.rb

@@ -1,50 +0,0 @@
-# coding: utf-8
-
-module Retter
-  class Binder
-    extend Configurable
-
-    configurable :allow_binding
-
-    def initialize(entries)
-      @entries         = entries
-      @singleton_pages = find_singleton_pages
-    end
-
-    def bind!
-      bind_entries
-
-      @singleton_pages.each(&:bind)
-    end
-
-    def bind_entries
-      @entries.each do |entry|
-        entry_page = Page::Entry.new(entry)
-        entry_page.bind
-
-        entry.articles.each do |article|
-          article_page = Page::Article.new(article)
-          article_page.bind
-        end
-      end
-    end
-
-    private
-
-    def find_singleton_pages
-      available_singleton_page_names.map {|name|
-        Page.const_get(name.capitalize).new
-      }
-    end
-
-    def available_singleton_page_names
-      availables = [:index]
-
-      unless allow_binding == :none
-        availables += allow_binding || [:profile, :entries, :feed]
-      end
-
-      availables.map(&:downcase).uniq
-    end
-  end
-end

data/lib/retter/command.rb

@@ -1,192 +0,0 @@
-# coding: utf-8
-
-require 'thor'
-require 'launchy'
-require 'pathname'
-
-module Retter
-  class Command < Thor
-    include Site
-
-    map '-v' => :version,
-        '-e' => :edit,
-        '-p' => :preview,
-        '-o' => :open,
-        '-r' => :rebind,
-        '-b' => :bind
-
-    desc :edit,    %(Open $EDITOR. Write an article with Markdown.)
-    method_options date: :string, key: :string, silent: :boolean
-    def edit(identifier = options[:date] || options[:key])
-      entry = entries.detect_by_string(identifier)
-
-      system config.editor, entry.path.to_path
-
-      invoke_after :edit
-    end
-
-    default_task :edit
-
-    desc :preview, %(Preview the draft article (browser will open).)
-    method_options date: :string, key: :string
-    def preview(identifier = options[:date] || options[:key])
-      preprint = Preprint.new
-      entry    = entries.detect_by_string(identifier)
-
-      preprint.bind entry
-
-      Launchy.open preprint.path.to_path
-    end
-
-    desc :open, %(Open your (static) site top page (browser will open).)
-    def open
-      index_page = Page::Index.new
-
-      Launchy.open index_page.path.to_path
-    end
-
-    desc :rebind,  %(Bind the draft article, re-generate all html pages.)
-    method_options silent: :boolean
-    def rebind
-      entries.commit_wip_entry!
-
-      Binder.new(entries).bind!
-
-      invoke_after :bind
-      invoke_after :rebind
-    end
-
-    desc 'bind',   %(Alias of rebind)
-    method_options silent: :boolean
-    alias_method   :bind, :rebind
-
-    desc :commit,  %(cd $RETTER_HOME && git add . && git commit -m 'Retter commit')
-    method_options silent: :boolean
-    def commit
-      Repository.open config.retter_home do |git|
-        say git.add(config.retter_home), :green
-        say git.commit_all('Retter commit'), :green
-      end
-
-      invoke_after :commit
-    end
-
-    desc :list, %(List retters)
-    def list
-      entries.each_with_index do |entry, n|
-        say "[e#{n}] #{entry.date}"
-        say "  #{entry.articles.map(&:title).join(', ')}"
-        say
-      end
-    end
-
-    desc :clean, %(Clear all caches)
-    def clean
-      return unless config.cache.respond_to?(:clear)
-
-      config.cache.clear
-    end
-
-    desc :home, %(Open a new shell in $RETTER_HOME)
-    def home
-      Dir.chdir config.retter_home.to_path
-
-      system config.shell
-
-      say 'bye', :green
-    end
-
-    desc :callback, %(Call a callback process only)
-    method_options  after: :string
-    def callback
-      invoke_after options[:after].intern
-    end
-
-    desc :new, %(Create a new site)
-    def new; end
-
-    desc :usage, %(Show usage.)
-    def usage
-      say Command.usage, :green
-    end
-
-    desc :version, %(Show version.)
-    def version
-      say "Retter version #{VERSION}"
-    end
-
-    private
-
-    def silent?
-      !options[:silent].nil?
-    end
-
-    def invoke_after(name)
-      return if silent?
-
-      case callback = after_callback(name)
-      when Proc
-        instance_eval &callback
-      when Symbol, String
-        __send__ callback
-      else
-        # noop
-      end
-    end
-
-    def after_callback(name)
-      config.after_callback(name)
-    end
-
-    def self.usage
-      <<-EOM
-Usage:
-  # 1. Startup
-  cd /path/to/dir
-  retter new my_sweet_diary
-  echo "export EDITOR=vim" >> ~/.zshenv # retter requires $EDITOR.
-  echo "export RETTER_HOME=/path/to/my_sweet_diary" >> ~/.zshenv
-  . ~/.zshenv
-
-  # 2. Write a article
-  retter         # $EDITOR will open. Write an article with Markdown.
-  retter preview # Preview the draft article (browser will open).
-
-  # 3. Publish
-  retter bind    # bind the draft article, re-generate all html pages.
-  retter commit  # shortcut of "cd $RETTER_HOME; git add .; git commit -m 'Retter commit'"
-  cd $RETTER_HOME
-  git push [remote] [branch] # or sftp, rsync, etc...
-
-  # Command options
-  retter edit 20110101
-  retter preview 20110101
-
-  retter edit today.md
-  retter edit 20110101.md
-  retter preview 20110101.md
-
-  # Browse entry list.
-  retter list
-
-  output examples:
-    [e0] 2011-11-07
-    entry3 title
-
-    [e1] 2011-10-25
-    entry2 title
-
-    [e2] 2011-10-22
-    entry1 title
-
-  to edit by keyword. run following command:
-    retter edit e1
-
-  # Browse offline.
-  retter open    # Open your (static) site top page (browser will open).
-
-  See also: https://github.com/hibariya/retter
-      EOM
-    end
-  end
-end

data/lib/retter/config.rb

@@ -1,96 +0,0 @@
-# coding: utf-8
-
-require 'active_support/cache'
-require 'forwardable'
-require 'fileutils'
-
-module Retter
-  class EnvError < RetterError; end
-
-  class Config
-    extend Forwardable
-
-    def_delegators Entries,      :retters_dir, :wip_file, :markup, :cache
-    def_delegators Markdown,     :renderer
-    def_delegators Binder,       :allow_binding
-    def_delegators Page,         :layouts_dir, :entries_dir
-    def_delegators Retter::Site, :title, :description, :url, :author
-    def_delegator  Retter::Site, :home, :retter_home
-
-    def initialize(env)
-      @env             = env
-      @after_callbacks = {}
-      @attributes      = {}
-
-      detect_retter_home
-      environments_required
-
-      load_defaults
-      load_retterfile
-    rescue EnvError => e
-      $stderr.puts e.message, Command.usage
-
-      exit 1
-    end
-
-    def after_callback(name, sym = nil, &block)
-      if callback = sym || block
-        @after_callbacks[name] = callback
-      else
-        @after_callbacks[name]
-      end
-    end
-
-    alias_method :after, :after_callback
-
-    [ # base
-      :editor, :shell,
-      # extra
-      :disqus_shortname
-    ].each do |att|
-      class_eval <<-EOM
-        def #{att}(val = nil)
-          val ? @attributes[:#{att}] = val : @attributes[:#{att}]
-        end
-      EOM
-    end
-
-    private
-
-    def detect_retter_home
-      @env['RETTER_HOME'] = Dir.pwd if File.exist? 'Retterfile'
-    end
-
-    def load_retterfile
-      retterfile = retter_home.join('Retterfile')
-
-      instance_eval retterfile.read, retterfile.to_path if retterfile.exist?
-    end
-
-    def environments_required
-      unless @env.values_at('EDITOR', 'RETTER_HOME').all?
-        raise EnvError, 'Set $RETTER_HOME and $EDITOR, first.'
-      end
-    end
-
-    def load_defaults
-      retter_home Pathname.new(@env['RETTER_HOME'])
-
-      editor @env['EDITOR']
-      shell  @env['SHELL']
-      url    'http://example.com'
-
-      renderer    Retter::Markdown::CodeRayRenderer
-      retters_dir retter_home.join('retters/')
-      wip_file    retters_dir.join('today.md')
-
-      layouts_dir retter_home.join('layouts/')
-      entries_dir retter_home.join('entries/')
-
-      cache_dir = retter_home.join('tmp/cache')
-      cache ActiveSupport::Cache::FileStore.new(cache_dir.to_path)
-
-      FileUtils.mkdir_p cache_dir.to_path unless cache_dir.directory? # for old versions
-    end
-  end
-end

data/lib/retter/configurable.rb

@@ -1,26 +0,0 @@
-# coding: utf-8
-
-module Retter
-  module Configurable
-    def configurable(*names)
-      names.each do |name|
-        define_configurable_method name
-        define_instance_shortcut_method name
-      end
-    end
-
-    def define_configurable_method(name)
-      instance_eval <<-EOM
-        def #{name}(val = nil)
-          val ? @#{name} = val : @#{name}
-        end
-      EOM
-    end
-
-    def define_instance_shortcut_method(name)
-      define_method name do
-        self.class.send(name)
-      end
-    end
-  end
-end

data/lib/retter/entries.rb

@@ -1,115 +0,0 @@
-# coding: utf-8
-
-require 'active_support/cache'
-require 'digest/sha1'
-require 'redcarpet'
-require 'chronic'
-
-module Retter
-  class EntryLoadError < RetterError; end
-
-  class Entries < Array
-    extend Configurable
-
-    configurable :retters_dir, :wip_file, :markup, :cache
-
-    def initialize
-      load_entries retters_dir
-    end
-
-    def retter_file(date)
-      retters_dir.join(date ? date.strftime('%Y%m%d.md') : 'today.md')
-    end
-
-    def detect_by_string(str)
-      entry =
-        case str
-        when nil, ''
-          detect_by_today || wip_entry
-        when /^e([0-9]+)$/
-          index = $1.to_i
-          self[index]
-        when /^([0-9a-z]+\.md)$/
-          detect_by_filename($1)
-        else
-          date = parse_date_string(str)
-          detect_by_date(date) || wip_entry(date)
-        end
-
-      raise EntryLoadError, "Entry not found with keyword '#{str}'" unless entry
-
-      entry
-    end
-
-    def detect_by_filename(filename)
-      case filename
-      when wip_file.basename.to_path
-        wip_entry
-      else
-        detect {|e| e.path.basename.to_path == filename }
-      end
-    end
-
-    def detect_by_today
-      detect_by_date(Date.today)
-    end
-
-    def detect_by_date(date)
-      detect {|e| e.date == date }
-    end
-
-    def parse_date_string(date_str)
-      normalized = date_str.gsub(/\./, ' ')
-
-      (Chronic.parse(normalized) || Date.parse(normalized)).to_date
-    end
-
-    def wip_entry(date = nil)
-      file = retter_file(date)
-      date = date || Date.today
-      body = file.exist? ? file.read : ''
-
-      Entry.new date: date, body: rendered_body(body), path: file, entries: self
-    end
-
-    def commit_wip_entry!
-      if wip_file.exist?
-        copy = wip_file.read
-        retter_file(Date.today).open('a') {|f| f.puts copy }
-        wip_file.unlink
-      end
-
-      reload
-    end
-
-    def load_entries(path)
-      date_files = find_markup_files(path).map {|file|
-        date_str = file.basename('.*').to_path
-        [Date.parse(date_str), file]
-      }.sort_by(&:first)
-
-      date_files.reverse_each {|date, file|
-        self << Entry.new(date: date, body: rendered_body(file.read), entries: self)
-      }
-    end
-
-    def reload
-      clear
-
-      load_entries retters_dir
-    end
-
-    def find_markup_files(path)
-      path = Pathname.new(path).realpath
-      Dir.open(path, &:to_a).grep(/^\d{4}(?:0[1-9]|1[012])(?:0[1-9]|[12][0-9]|3[01])\..*$/).map {|f| path.join f }
-    end
-
-    def rendered_body(body)
-      key = Digest::SHA1.hexdigest('entry_' + body)
-
-      cache.fetch(key) do
-        (markup || Markdown.instance).render(body)
-      end
-    end
-  end
-end