puffs 0.2.04 → 0.2.05

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62f1bbad581f546893650f943280678b704a8e61
-  data.tar.gz: 3820cd8108d253066d339e762628ca37545b1599
+  metadata.gz: c18567a1d51b75d3ad758258c55923663e43bd96
+  data.tar.gz: 35baf154d55ce813ad53d2b260c78a36b3925b14
 SHA512:
-  metadata.gz: 39b03317cdd9fc533a8212786cde172eb66d0a512adfb32c1723dfa4ea58b21d0aa752bc0d88a5460b4509d9d45d55c98ae9729032018c96488ea6731c9c107e
-  data.tar.gz: 5f15695eb605caf6a1ff4ed2454d8d01d571a912e073528e0c98feddb52bc8b88e9af3df9a94fdc789048eae8ee7e2c8f651f5b241c2c6e135b87aaf41acbcb9
+  metadata.gz: 2e2c6e55a65a3aac467c51b21a93cc845489926d3c33186d6e311533bfdff2fc316ba9c2648a131127ff21cccbf76627b4c35dcbe2d977a20895272fa6be94c2
+  data.tar.gz: 6a7c885f4e2e91700482a70d8ebe6447f55fea35fb4ed36ee498281439dd1f2b42d1d9ff4d36a7b18a4d1ebc2091da80ab43355d637c3fe2d627edc06efc5c9e

data/bin/puffs

@@ -3,13 +3,14 @@
 require 'rubygems'
 require 'thor'
 
+# Used to create models, controllers, and migrations. Alias 'g.'
 class Generate < Thor
-  desc "model <name>", "generate a model with the specified name."
+  desc 'model <name>', 'generate a model with the specified name.'
   def model(name)
     m_name = name.capitalize
 
-    #writes model file
-    File.open("./app/models/#{m_name.downcase}.rb", "w") do |f|
+    # Writes model file
+    File.open("./app/models/#{m_name.downcase}.rb", 'w') do |f|
       f.write("class #{m_name} < Puffs::SQLObject\n\n")
       f.write("end\n")
       f.write("#{m_name}.finalize!")
@@ -18,63 +19,65 @@ class Generate < Thor
     puts "#{m_name} model created"
   end
 
-  desc "controller <name>", "generate a controller with the specified name."
+  desc 'controller <name>', 'generate a controller with the specified name.'
   def controller(name)
     c_name = name.capitalize
 
-    #Writes controller file
-    File.open("./app/controllers/#{c_name.downcase}.rb", "w") do |f|
+    # Writes controller file
+    File.open("./app/controllers/#{c_name.downcase}.rb", 'w') do |f|
       f.write("class #{c_name}Controller < Puffs::ControllerBase\n\n")
-      f.write("end")
+      f.write('end')
     end
 
-    #creates empty views directory
+    # Creates empty views directory
     Dir.mkdir "./app/views/#{c_name.downcase}_controller"
     puts "#{c_name} controller created"
   end
 
-  desc "migration <name>", "generates an empty sql file with a filename of the specified <name> appended to a timestamp"
+  desc 'migration <name>', 'generates an empty sql file with a filename of the specified <name> appended to a timestamp'
   def migration(name)
-    #create a timestamp
-    ts = Time.now.to_s.split(" ").take(2).join("").split("").map{|el| el.to_i}.join
+    # Create a timestamp
+    ts = Time.now.to_s.split(' ').take(2).join('').split('').map(&:to_i).join
     require 'active_support/inflector'
     filename = "#{ts}__#{name.underscore.downcase}"
 
-    #create the migration file
-    File.open("./db/migrate/#{filename}.sql", "w") do |f|
-      f.write ("CREATE TABLE IF NOT EXISTS #{name} (\n")
-      f.write ("\tid SERIAL PRIMARY KEY,\n")
-      f.write ("\tname VARCHAR(255) NOT NULL")
-      f.write (");")
+    # Create the migration file
+    File.open("./db/migrate/#{filename}.sql", 'w') do |f|
+      f.write "CREATE TABLE IF NOT EXISTS #{name} (\n"
+      f.write "\tid SERIAL PRIMARY KEY,\n"
+      f.write "\tname VARCHAR(255) NOT NULL"
+      f.write ');'
     end
   end
 end
 
+# Top-level command for manipulating the database file.
 class Db < Thor
-  desc "create", "creates the DB"
+  desc 'create', 'creates the DB'
   def create
-    #Drops Puffs postgres database and recreates it.
+    # Drops puffs postgres database and recreates it.
     require_relative '../lib/db_connection'
-    DBConnection.reset
+    Puffs::DBConnection.reset
     puts 'db created!'
   end
 
-  desc "migrate", "runs pending migrations"
+  desc 'migrate', 'runs pending migrations'
   def migrate
-    #Creates Version table if necessary, then runs needed migrations in order.
+    # Creates Version table if necessary,
+    # then runs needed migrations in order.
     require_relative '../lib/db_connection'
-    DBConnection.migrate
-    puts "migrated!"
+    Puffs::DBConnection.migrate
+    puts 'migrated!'
   end
 
-  desc "seed", "seeds the DB"
+  desc 'seed', 'seeds the DB'
   def seed
     require_relative '../lib/puffs'
-    Seed.populate
+    Puffs::Seed.populate
     puts 'db seeded!'
   end
 
-  desc "reset", "resets the DB and seeds it"
+  desc 'reset', 'resets the DB and seeds it'
   def reset
     create
     migrate
@@ -83,17 +86,18 @@ class Db < Thor
   end
 end
 
+# Top-level Thor class. Executes with 'puffs' after bundling.
 class CLI < Thor
   register(Generate, 'generate', 'generate <command>', 'Generates a model or controller.')
   register(Db, 'db', 'db <command>', 'Accesses commands for the DB.')
 
-  desc "g", "alias of generate subcommand"
+  desc 'g', 'alias of generate subcommand'
   subcommand 'g', Generate
 
   desc 'server', 'starts the Puffs server'
   def server
     require_relative '../lib/puffs'
-    ServerConnection.start
+    Puffs::ServerConnection.start
   end
 
   desc 'new', 'creates a new Puffs app'
@@ -101,26 +105,26 @@ class CLI < Thor
     Dir.mkdir "./#{name}"
     Dir.mkdir "./#{name}/config"
 
-    File.open("./#{name}/config/database.yml", "w") do |f|
+    File.open("./#{name}/config/database.yml", 'w') do |f|
       f.write("database: #{name}")
     end
-    
+
     Dir.mkdir "./#{name}/app"
     Dir.mkdir "./#{name}/app/models"
     Dir.mkdir "./#{name}/app/views"
     Dir.mkdir "./#{name}/app/controllers"
-    File.open("./#{name}/app/controllers/application_controller.rb", "w") do |f|
+    File.open("./#{name}/app/controllers/application_controller.rb", 'w') do |f|
       f.write File.read(File.expand_path('../../template/app/controllers/application_controller.rb', __FILE__))
     end
-    File.open("./#{name}/config/routes.rb", "w") do |f|
+    File.open("./#{name}/config/routes.rb", 'w') do |f|
       f.write File.read(File.expand_path('../../template/config/routes.rb', __FILE__))
     end
     Dir.mkdir "./#{name}/db"
     Dir.mkdir "./#{name}/db/migrate"
-    File.open("./#{name}/db/seeds.rb", "w") do |f|
+    File.open("./#{name}/db/seeds.rb", 'w') do |f|
       f.write File.read(File.expand_path('../../template/db/seeds.rb', __FILE__))
     end
-    File.open("./#{name}/Gemfile", "w") do |f|
+    File.open("./#{name}/Gemfile", 'w') do |f|
       f.write File.read(File.expand_path('../../template/Gemfile', __FILE__))
     end
   end

data/lib/controller_base.rb

@@ -3,73 +3,73 @@ require 'active_support/core_ext'
 require 'erb'
 require_relative 'session'
 require 'active_support/inflector'
-# require_relative 'puffs'
 
-class Puffs::ControllerBase
-  attr_reader :req, :res, :params
+# Puffs controller
+module Puffs
+  class ControllerBase
+    attr_reader :req, :res, :params
 
-  # Setup the controller
-  def initialize(req, res, route_params = {})
-    @req, @res = req, res
-    @params = req.params.merge(route_params)
-  end
+    # Setup the controller
+    def initialize(req, res, route_params = {})
+      @req, @res = req, res
+      @params = req.params.merge(route_params)
+    end
 
-  # Helper method to alias @already_built_response
-  def already_built_response?
-    @already_built_response ||= false
-  end
+    # Helper method to alias @already_built_response
+    def already_built_response?
+      @already_built_response ||= false
+    end
 
-  # Set the response status code and header
-  def redirect_to(url)
-    raise DoubleRenderError if already_built_response?
-    res.header['location'] = url
-    res.status = 302
-    @already_built_response = true
-    session.store_session(res)
-  end
+    # Set the response status code and header
+    def redirect_to(url)
+      raise DoubleRenderError if already_built_response?
+      res.header['location'] = url
+      res.status = 302
+      @already_built_response = true
+      session.store_session(res)
+    end
 
-  # Populate the response with content.
-  # Set the response's content type to the given type.
-  # Raise an error if the developer tries to double render.
-  def render_content(content, content_type)
-    raise DoubleRenderError if already_built_response?
-    res['Content-Type'] = content_type
-    res.body = [content]
-    @already_built_response = true
-    session.store_session(res)
-  end
+    # Populate the response with content.
+    # Set the response's content type to the given type.
+    # Raise an error if the developer tries to double render.
+    def render_content(content, content_type)
+      raise DoubleRenderError if already_built_response?
+      res['Content-Type'] = content_type
+      res.body = [content]
+      @already_built_response = true
+      session.store_session(res)
+    end
 
-  # use ERB and binding to evaluate templates
-  # pass the rendered html to render_content
-  def render(template_name)
-    body_string = ""
-    File.open("./app/views/#{controller_name}/#{template_name}.html.erb", "r") do |f|
-      f.each_line do |line|
-        body_string += line
+    # use ERB and binding to evaluate templates
+    # pass the rendered html to render_content
+    def render(template_name)
+      body_string = ''
+      File.open("./app/views/#{controller_name}/#{template_name}.html.erb", 'r') do |f|
+        f.each_line do |line|
+          body_string += line
+        end
       end
+
+      content = ERB.new(body_string).result(binding)
+      render_content(content, 'text/html')
     end
-    #File.readlines
-    #File.read
 
-    content = ERB.new(body_string).result(binding)
-    render_content(content, 'text/html')
-  end
+    # method exposing a `Session` object
+    def session
+      @session ||= Puffs::Session.new(req)
+    end
 
-  # method exposing a `Session` object
-  def session
-    @session ||= Session.new(req)
-  end
+    # use this with the router to call action_name (:index, :show, :create...)
+    def invoke_action(name)
+      send(name)
+      render(name) unless already_built_response?
+    end
 
-  # use this with the router to call action_name (:index, :show, :create...)
-  def invoke_action(name)
-    self.send(name)
-    render(name) unless already_built_response?
+    def controller_name
+      self.class.name.underscore
+    end
   end
 
-  def controller_name
-    self.class.name.underscore
+  class DoubleRenderError < RuntimeError
   end
 end
-
-class DoubleRenderError < RuntimeError
-end

data/lib/db_connection.rb

@@ -4,111 +4,116 @@ require 'yaml'
 PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
 MIGRATIONS = Dir.glob('./db/migrate/*.sql').to_a
 
-class DBConnection
-  def self.app_name
-    YAML.load_file(Dir.pwd + '/config/database.yml')['database']
-  end
+module Puffs
+  # Connects to the Postgres DB.
+  class DBConnection
+    def self.app_name
+      YAML.load_file(Dir.pwd + '/config/database.yml')['database']
+    end
 
-  def self.open
-    @db = PG::Connection.new( :dbname => DBConnection.app_name, :port => 5432 )
-  end
+    def self.add_to_version(file)
+      name = parse_migration_file(file)
+      execute(<<-SQL, [name])
+        INSERT INTO
+          version (name)
+        VALUES
+          ($1);
+      SQL
+    end
 
-  def self.reset
-    commands = [
-      "dropdb #{DBConnection.app_name}",
-      "createdb #{DBConnection.app_name}"
-    ]
+    def self.columns(table_name)
+      columns = instance.exec(<<-SQL)
+        SELECT
+          attname
+        FROM
+          pg_attribute
+        WHERE
+          attrelid = '#{table_name}'::regclass AND
+          attnum > 0 AND
+          NOT attisdropped
+      SQL
 
-    commands.each { |command| `#{command}` }
-  end
+      columns.map { |col| col['attname'].to_sym }
+    end
 
-  def self.migrate
-    ensure_version_table
-    to_migrate = MIGRATIONS.reject { |file| has_migrated?(file) }
-    to_migrate.each { |file| add_to_version(file) }
-    to_migrate.map {|file| "psql -d #{DBConnection.app_name} -a -f #{file}"}
-              .each {|command| `#{command}`}
-  end
+    def self.ensure_version_table
+      # TODO: Find a reliable way to query db to see if version table exists.
+      table = nil
+
+      if table.nil?
+        execute(<<-SQL)
+          CREATE TABLE IF NOT EXISTS version (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255) NOT NULL
+          );
+        SQL
+      end
+    end
 
-  def self.parse_migration_file(file)
-    filename = File.basename(file).split(".").first
-    u_idx = filename.index("_")
-    filename[0..u_idx - 1]
-  end
+    def self.execute(*args)
+      print_query(*args)
+      instance.exec(*args)
+    end
 
-  def self.has_migrated?(file)
-    name = parse_migration_file(file)
-    result = execute(<<-SQL, [name])
-      SELECT
-        *
-      FROM
-        version
-      WHERE
-        name = $1;
-    SQL
-    !!result.first
-  end
+    def self.instance
+      open if @db.nil?
 
-  def self.add_to_version(file)
-    name = parse_migration_file(file)
-    execute(<<-SQL, [name])
-      INSERT INTO
-        version (name)
-      VALUES
-        ($1);
-    SQL
-  end
+      @db
+    end
 
-  def self.instance
-    self.open if @db.nil?
+    def self.migrate
+      ensure_version_table
+      to_migrate = MIGRATIONS.reject { |file| migrated?(file) }
+      to_migrate.each do |file|
+        add_to_version(file)
+        `psql -d #{app_name} -a -f #{file}`
+      end
+    end
 
-    @db
-  end
+    def self.migrated?(file)
+      name = parse_migration_file(file)
+      result = execute(<<-SQL, [name])
+        SELECT
+          *
+        FROM
+          version
+        WHERE
+          name = $1;
+      SQL
+      !!result.first
+    end
 
-  def self.execute(*args)
-    print_query(*args)
-    instance.exec(*args)
-  end
+    def self.parse_migration_file(file)
+      filename = File.basename(file).split('.').first
+      u_idx = filename.index('_')
+      filename[0..u_idx - 1]
+    end
 
-  def self.ensure_version_table
-    #find a reliable way to query db to see if version table exists.
-    table = nil
+    def self.print_query(query, *interpolation_args)
+      return unless PRINT_QUERIES
 
-    if table.nil?
-      self.execute(<<-SQL)
-        CREATE TABLE IF NOT EXISTS version (
-          id SERIAL PRIMARY KEY,
-          name VARCHAR(255) NOT NULL
-        );
-      SQL
+      puts '--------------------'
+      puts query
+      unless interpolation_args.empty?
+        puts "interpolate: #{interpolation_args.inspect}"
+      end
+      puts '--------------------'
     end
-  end
 
-  def self.columns(table_name)
-    columns = instance.exec(<<-SQL)
-      SELECT
-        attname
-      FROM
-        pg_attribute
-      WHERE
-        attrelid = '#{table_name}'::regclass AND
-        attnum > 0 AND
-        NOT attisdropped
-    SQL
-
-    columns.map { |col| col['attname'].to_sym }
-  end
-
-  private
+    def self.open
+      @db = PG::Connection.new(
+        dbname: app_name,
+        port: 5432
+      )
+    end
 
-  def self.print_query(query, *interpolation_args)
-    return unless PRINT_QUERIES
+    def self.reset
+      commands = [
+        "dropdb #{app_name}",
+        "createdb #{app_name}"
+      ]
 
-    puts '--------------------'
-    puts query
-    unless interpolation_args.empty?
-      puts "interpolate: #{interpolation_args.inspect}"
+      commands.each { |command| `#{command}` }
     end
-    puts '--------------------'
   end
 end

data/lib/puffs.rb

@@ -1,12 +1,12 @@
+# Enjoy puffs.
 module Puffs
-  #enjoy puffs
 end
 
-require_relative "sql_object/sql_object"
-require_relative "controller_base"
+require_relative 'sql_object/sql_object'
+require_relative 'controller_base'
 
-Dir.glob('./app/models/*.rb') {|file| require file}
-Dir.glob('./app/controllers/*.rb') {|file| require file}
+Dir.glob('./app/models/*.rb') { |file| require file }
+Dir.glob('./app/controllers/*.rb') { |file| require file }
 
 require './db/seeds'