days 0.0.1.earlier → 0.1.0

data/lib/days/command.rb

@@ -0,0 +1,158 @@
+require 'thor'
+require 'fileutils'
+require_relative 'config'
+require_relative 'app'
+require_relative 'migrator'
+
+module Days
+  class Command < Thor
+    SKELETON_PATH = File.expand_path(File.join(__FILE__, '..', '..', '..', 'skeleton', 'days'))
+    desc "init [DIR]", "Initialize days.gem world in the directory (default = ./)"
+    def init(dir = ".")
+      puts "Initializing new Days environment on #{File.expand_path dir}"
+      FileUtils.cp_r Dir["#{SKELETON_PATH}/*"], "#{dir}/"
+    end
+
+    desc "init_theme [DIR]", "Generate template of theme (views) to DIR (default = ./)"
+    def init_theme(dir = ".")
+      if File.exists?(File.join(dir, 'views')) || File.exists?(File.join(dir, 'stylesheets'))
+        puts "This will override the following:"
+        puts "* #{dir}/views/entries.haml"
+        puts "* #{dir}/views/entry.haml"
+        puts "* #{dir}/views/layout.haml"
+        puts "* #{dir}/stylesheets/style.scss"
+
+        print "Continue (y/n)? "
+
+        while _ = $stdin.gets
+          case _
+          when /^y|yes$/
+            break
+          when /^n|no$/
+            puts 'Cancelled.'
+            return
+          else
+            print "Please answer in 'yes' or 'no' or 'y' or 'n': "
+          end
+        end
+      end
+
+      require 'fileutils'
+
+      root = File.expand_path(File.join(__FILE__, '..', '..', '..', 'app'))
+      FileUtils.mkdir_p File.join(dir, 'views')
+      FileUtils.mkdir_p File.join(dir, 'stylesheets')
+
+      %w(entries.haml entry.haml layout.haml).each do |file|
+        FileUtils.cp(File.join(root, 'views', file),
+                     File.join(dir,  'views', file))
+      end
+
+      FileUtils.cp(File.join(root, 'stylesheets', 'style.scss'),
+                   File.join(dir,  'stylesheets', 'style.scss'))
+    end
+
+    desc "server", "Starts the server"
+    method_option :config, :type => :string, :aliases => "-c"
+    method_option :port, :type => :numeric, :aliases => "-p", :default => 3162
+    method_option :bind, :type => :string, :aliases => "-b", :default => nil
+    method_option :environment, :type => :string, :aliases => "-e", :default => "development"
+    method_option :pid, :type => :string, :aliases => "-c"
+    def server
+      set_env
+      App.config = config
+      rack_options = {
+        app: App.rack,
+        Port: options[:port],
+        Host: options[:bind],
+        daemonize: options[:daemonize],
+        environment: options[:environment],
+        server: options[:server],
+      }
+      rack_options.merge!(pid: File.expand_path(options[:pid])) if options[:pid]
+      Rack::Server.start(rack_options)
+    end
+
+    # desc "precompile", "Precompile the assets for production"
+    # method_option :config, :type => :string, :aliases => "-c"
+    # def precompile
+    # end
+
+    desc "migrate [ENV]", "Run database migration for environment (default = development)"
+    method_option :config, :type => :string, :aliases => "-c"
+    method_option :version, :type => :numeric, :aliases => "-v", :default => nil
+    method_option :scope, :type => :string, :aliases => "-s"
+    method_option :verbose, :type => :boolean, :aliases => "-V", :default => true
+    def migrate(env = "development")
+      set_env env
+      Days::Migrator.start(config, options)
+    end
+
+    desc "console [ENV]", "Start console using pry (default = development)"
+    method_option :config, :type => :string, :aliases => "-c"
+    def console(env = "development")
+      set_env env
+      require 'pry'
+      require_relative 'models'
+      config.establish_db_connection()
+      Pry.start(binding)
+    end
+
+    desc "import FILE", "Import entries from file."
+    method_option :config, :type => :string, :aliases => "-c"
+    method_option :environment, :type => :string, :aliases => "-e", :default => "development"
+    def import(file)
+      set_env
+      config.establish_db_connection()
+      require 'json'
+      users = {}
+      categories = {}
+      open(file, 'r') do |io|
+        io.readlines.each do |line|
+          line = JSON.parse(line)
+
+          attributes ={}
+          if Entry.where(id: line['id']).count.zero?
+            attributes[:id] = line['id']
+          end
+
+          if line['user']
+            if users.has_key?(line['user'])
+              user = users[line['user']]
+            else
+              user = users[line['user']] = User.where(login_name: line['user']).first
+            end
+
+
+            attributes[:user] = user if user
+          end
+
+          if line['category']
+            attributes[:categories] = line['category'].map do |category_name|
+              categories[category_name] ||= Category.find_or_create_by_name!(category_name)
+            end
+          end
+
+          attributes[:slug] = line['slug'] if line['slug']
+          attributes[:title] = line['title'] if line['title']
+          attributes[:body] = line['body'] if line['body']
+          attributes[:published_at] = line['published_at'] if line['published_at']
+          attributes[:draft] = line['draft'] if line['draft']
+
+          p attributes[:title]
+          Entry.create!(attributes)
+        end
+      end
+    end
+
+    private
+
+    def set_env(env = nil)
+      App.environment = env || options[:environment] || ENV["RACK_ENV"] || :development
+    end
+
+    def config
+      @_days_config ||= Config.new(options[:config] || "./config.yml")
+    end
+  end
+end

data/lib/days/config.rb

@@ -0,0 +1,42 @@
+require_relative 'app'
+require 'active_record'
+require 'logger'
+require 'settingslogic'
+
+module Days
+  class Config < Settingslogic
+    namespace App.environment.to_s
+
+    def initialize(hash_or_file = {}, section = nil)
+      super
+      if section.nil?
+        if String === hash_or_file
+          self[:root] = File.dirname(hash_or_file)
+        else
+          self[:root] = "."
+        end
+
+        self['database'].tap do |hash|
+          next unless hash
+          if hash['adapter'] == 'sqlite3' && /^\// !~ hash['database']
+            hash['database'] = File.join(self.root, hash['database'])
+          end
+        end
+      end
+    end
+
+    def establish_db_connection(force=false)
+      if !self.has_key?(:activerecord_log) || self.activerecord_log == true
+        ActiveRecord::Base.logger = Logger.new($stdout)
+      end
+
+      begin
+        raise ActiveRecord::ConnectionNotEstablished if force
+        return ActiveRecord::Base.connection
+      rescue ActiveRecord::ConnectionNotEstablished
+        ActiveRecord::Base.establish_connection(self['database'] ? Hash[self.database] : ENV["DATABASE_URL"])
+        retry
+      end
+    end
+  end
+end

data/lib/days/helpers.rb

@@ -0,0 +1,101 @@
+require 'rack/csrf'
+
+module Days
+  module Helpers
+    def config
+      Days::App.config
+    end
+
+    def logged_in?
+      !!session[:user_id]
+    end
+
+    def current_user
+      @current_user ||= session[:user_id] ? User.where(id: session[:user_id]).first : nil
+    end
+
+    def csrf_token
+      Rack::Csrf.csrf_token(env)
+    end
+
+    def csrf_tag
+      Rack::Csrf.csrf_tag(env)
+    end
+
+    def entry_path(entry)
+      return nil unless entry.published?
+
+      published_at = entry.published_at
+      hash = {
+        year: published_at.year.to_s.rjust(2, '0'),
+        month: published_at.month.to_s.rjust(2, '0'),
+        day: published_at.day.to_s.rjust(2, '0'),
+        hour: published_at.hour.to_s.rjust(2, '0'),
+        minute: published_at.min.to_s.rjust(2, '0'),
+        second: published_at.sec.to_s.rjust(2, '0'),
+        slug: entry.slug, id: entry.id
+      }
+      config.permalink.gsub(/{(\w+?)}/) { hash[$1.to_sym] }
+    end
+
+    def lookup_entry(path)
+      regexp = Regexp.compile(Regexp.escape(config.permalink).gsub(/\\{(\w+?)\\}/) { "(?<#{$1}>.+?)" } + "$")
+      m = regexp.match(path)
+      return nil unless m
+
+      match = m.names.inject({}) do |hash, k|
+        hash[k.to_sym] = m[k]
+        hash
+      end
+
+
+      if match[:id] || match[:slug]
+        if match[:id]
+          query = Entry.where(id: match[:id])
+        else
+          query = Entry.where(slug: match[:slug])
+        end
+
+        entry = query.first
+        return nil unless entry
+        published_at = entry.published_at
+        return nil unless published_at
+
+        return nil if match[:slug]   && match[:slug]        != entry.slug
+        return nil if match[:id]     && match[:id].to_i     != entry.id
+        return nil if match[:year]   && match[:year].to_i   != published_at.year
+        return nil if match[:month]  && match[:month].to_i  != published_at.month
+        return nil if match[:day]    && match[:day].to_i    != published_at.day
+        return nil if match[:hour]   && match[:hour].to_i   != published_at.hour
+        return nil if match[:minute] && match[:minute].to_i != published_at.min
+        return nil if match[:second] && match[:second].to_i != published_at.sec
+
+        return entry
+      else
+        match_time = {}.tap do |h|
+          [:year, :month, :day, :hour, :minute, :second].each do |k|
+            h[k] = match[k] && match[k].to_i
+          end
+        end
+        range_begin = Time.local(
+          match_time[:year], match_time[:month] || 1, match_time[:day] || 1,
+          match_time[:hour] || 0, match_time[:minute] || 0, match_time[:second] || 0
+        )
+        range_end = Time.local(
+          match_time[:year], match_time[:month] || 12, match_time[:day] || 31,
+          match_time[:hour] || 23, match_time[:minute] || 59, match_time[:second] || 59
+        )
+
+        query = Entry.where(published_at: (range_begin .. range_end))
+
+        if query.count.zero?
+          return nil
+        elsif query.count == 1
+          return query.first
+        else
+          return query
+        end
+      end
+    end
+  end
+end

data/lib/days/migrate/20121221000000_create_entries.rb

@@ -0,0 +1,18 @@
+class CreateEntries < ActiveRecord::Migration
+  def change
+    create_table :entries do |t|
+      t.string :title
+      t.text :body
+      t.text :rendered
+      t.datetime :published_at
+      t.integer :user_id
+      t.string :slug
+
+      t.timestamps
+    end
+
+    add_index :entries, :published_at
+    add_index :entries, :user_id
+    add_index :entries, :slug
+  end
+end

data/lib/days/migrate/20121221001000_create_users.rb

@@ -0,0 +1,12 @@
+class CreateUsers < ActiveRecord::Migration
+  def change
+    create_table :users do |t|
+      t.string :login_name
+      t.binary :password_digest
+
+      t.string :name
+    end
+
+    add_index :users, :login_name
+  end
+end

data/lib/days/migrate/20121221002000_create_categories.rb

@@ -0,0 +1,17 @@
+class CreateCategories < ActiveRecord::Migration
+  def change
+    create_table :categories do |t|
+      t.string :name
+    end
+
+    create_table :categories_entries do |t|
+      t.integer :category_id
+      t.integer :entry_id
+    end
+
+    add_index :categories, :name
+
+    add_index :categories_entries, :entry_id
+    add_index :categories_entries, :category_id
+  end
+end

data/lib/days/migrator.rb

@@ -0,0 +1,33 @@
+module Days
+  module Migrator
+    def self.start(config, options = {})
+      require 'active_record'
+      require 'active_support/core_ext/class/attribute_accessors.rb'
+      require 'active_record/schema_dumper'
+
+      config.establish_db_connection()
+      orig_logger = ActiveRecord::Base.logger
+      begin
+        ActiveRecord::Base.logger = nil unless options[:show_sql]
+        ActiveRecord::Migration.verbose = options[:verbose]
+
+        migration_paths = [
+          config[:migration_path] || "#{config.root}/db/migrate",
+          File.expand_path(File.join(__FILE__, '..', 'migrate'))
+        ]
+        ActiveRecord::Migrator.migrate(migration_paths, options[:version]) do |migration|
+          options[:scope].blank? || (options[:scope] == migration.scope)
+        end
+
+        schema_file = config[:schema] || "#{config.root}/db/schema.rb"
+        File.open(schema_file, "w:utf-8") do |io|
+          ActiveRecord::SchemaDumper.dump ActiveRecord::Base.connection, io
+        end
+
+        self
+      ensure
+        ActiveRecord::Base.logger = orig_logger
+      end
+    end
+  end
+end

data/lib/days/models/category.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+
+module Days
+  class Category < ActiveRecord::Base
+    attr_accessible :name
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+
+    has_and_belongs_to_many :entries, class_name: 'Days::Entry'
+  end
+end

data/lib/days/models/entry.rb

@@ -0,0 +1,63 @@
+require 'active_record'
+require 'stringex'
+require 'redcarpet'
+
+module Days
+  class Entry < ActiveRecord::Base
+    attr_accessible :title, :body, :slug, :published_at, :categories, :user, :draft
+
+    validates_uniqueness_of :slug
+    validates_presence_of :title, :body, :rendered, :slug
+
+    belongs_to :user, class_name: 'Days::User'
+    has_and_belongs_to_many :categories, class_name: 'Days::Category'
+
+    scope :published, -> do
+      includes(:categories).
+      where('published_at IS NOT NULL AND published_at <= ?', Time.now).
+      order('published_at DESC')
+    end
+
+    def draft=(x)
+      if x.present?
+        @draft = true
+      else
+        @draft = false
+      end
+    end
+
+    def draft?
+      @draft
+    end
+    alias draft draft?
+
+    def published?
+      self.published_at && self.published_at <= Time.now
+    end
+
+    def scheduled?
+      self.published_at && Time.now < self.published_at
+    end
+
+    def short_rendered
+      self.rendered.gsub(/<!-- *more *-->.+\z/m, block_given? ? yield(self) : '')
+    end
+
+    before_validation do
+      if draft?
+        self.published_at = nil
+      else
+        self.published_at ||= Time.now
+      end
+
+      if self.title && (!self.slug || self.slug.empty?)
+        self.slug = self.title.to_url
+      end
+      markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML,
+        :autolink => true, :space_after_headers => true,
+        :no_intra_emphasis => true, :fenced_code_blocks => true,
+        :tables => true, :superscript => true)
+      self.rendered = markdown.render(self.body)
+    end
+  end
+end

data/lib/days/models/user.rb

@@ -0,0 +1,14 @@
+require 'active_record'
+
+module Days
+  class User < ActiveRecord::Base
+    has_secure_password
+
+    attr_accessible :login_name, :name, :password, :password_confirmation
+
+    validates_uniqueness_of :login_name
+    validates_presence_of :login_name, :name
+
+    has_many :entries, class_name: 'Days::Entry'
+  end
+end

data/lib/days/models.rb

@@ -0,0 +1,7 @@
+%w[
+  user
+  category
+  entry
+].each do |m|
+  require "days/models/#{m}"
+end

data/lib/days/version.rb

@@ -1,3 +1,3 @@
 module Days
-  VERSION = "0.0.1.earlier"
+  VERSION = "0.1.0"
 end

data/lib/days.rb

@@ -1,5 +1,7 @@
 require "days/version"
+require "days/config"
+require "days/models"
+require "days/app"
 
 module Days
-  # Your code goes here...
 end

data/scripts/lokka_export.rb

@@ -0,0 +1,45 @@
+require 'active_record'
+require 'json'
+
+ActiveRecord::Base.establish_connection ENV["DATABASE_URL"]
+
+class User < ActiveRecord::Base
+  has_many :entries
+end
+
+class Category < ActiveRecord::Base
+  has_many :entries
+end
+
+class Entry < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :category
+end
+
+class Post < Entry
+end
+
+Post.order('id ASC').all.each do |post|
+  if 'kramdown' != post.markup
+    warn "WARN: #{post.slug} (#{post.id}) is not written in kramdown"
+  end
+
+  hash = {}
+  hash[:id] = post.id
+  hash[:user] = post.user.name
+  hash[:slug] = post.slug
+  hash[:title] = post.title
+  hash[:body] = post.body
+  if post.draft == 1
+    hash[:published_at] = post.created_at
+  else
+    hash[:published_at] = nil
+    hash[:draft] = true
+  end
+  if post.category
+    hash[:category] = [post.category.title]
+  else
+    hash[:category] = []
+  end
+  puts hash.to_json
+end

data/skeleton/days/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+gem "days"
+
+group :production do
+  # gem "mysql2"
+end
+
+group :development do
+  gem "sqlite3"
+end

data/skeleton/days/config.ru

@@ -0,0 +1,6 @@
+require 'bundler'
+require 'days'
+Bundler.require(:default, Days::App.environment)
+
+Days::App.set :config, Days::Config.new("#{File.dirname(__FILE__)}/config.yml")
+run Days::App.rack

data/skeleton/days/config.yml

@@ -0,0 +1,33 @@
+defaults: &defaults
+  base_path: "/"
+  permalink: "/{year}/{month}/{slug}"
+  title: "My Blog"
+
+development:
+  <<: *defaults
+  database:
+    adapter: sqlite3
+    database: db/development.sqlite3
+    pool: 5
+    timeout: 5000
+
+test:
+  <<: *defaults
+  database:
+    adapter: sqlite3
+    database: db/test.sqlite3
+    pool: 5
+    timeout: 5000
+
+production:
+  <<: *defaults
+<% unless ENV["DATABASE_URL"] %>
+  database:
+    adapter: mysql2
+    encoding: utf8
+    database: days_production
+    pool: 5
+    username: foo
+    password: bar
+    socket: /tmp/mysql.sock
+<% end %>