puffs 0.2.04 → 0.2.05

data/lib/relation.rb

@@ -1,206 +1,208 @@
 require_relative './../lib/db_connection'
 require_relative 'sql_object/sql_object'
 
-class Puffs::SQLRelation
-  def self.build_association(base, included, method_name)
-    base.included_relations << included
+module Puffs
+  class SQLRelation
+    def self.build_association(base, included, method_name)
+      base.included_relations << included
+
+      assoc_options = base.klass.assoc_options[method_name]
+      has_many = assoc_options.class == HasManyOptions
+
+      if has_many
+        i_send = assoc_options.foreign_key
+        b_send = assoc_options.primary_key
+      else
+        i_send = assoc_options.primary_key
+        b_send = assoc_options.foreign_key
+      end
 
-    assoc_options = base.klass.assoc_options[method_name]
-    has_many = assoc_options.class == HasManyOptions
+      match = proc do
+        selection = included.select do |i_sql_obj|
+          i_sql_obj.send(i_send) == self.send(b_send)
+        end
 
-    if has_many
-      i_send = assoc_options.foreign_key
-      b_send = assoc_options.primary_key
-    else
-      i_send = assoc_options.primary_key
-      b_send = assoc_options.foreign_key
-    end
+        associated = has_many ? selection : selection.first
 
-    match = proc do
-      selection = included.select do |i_sql_obj|
-        i_sql_obj.send(i_send) == self.send(b_send)
+        #After we find our values iteratively, we overwrite the method again
+        #to the result values to reduce future lookup time to O(1).
+        new_match = proc { associated }
+        Puffs::SQLObject.define_singleton_method_by_proc(
+          self, method_name, new_match)
+
+        associated
       end
 
-      associated = has_many ? selection : selection.first
+      #we overwrite the association method for each SQLObject in the
+      #collection so that it points to our cached relation and doesn't fire a query.
+      base.collection.each do |b_sql_obj|
+        Puffs::SQLObject.define_singleton_method_by_proc(
+          b_sql_obj, method_name, match)
+      end
+    end
 
-      #After we find our values iteratively, we overwrite the method again
-      #to the result values to reduce future lookup time to O(1).
-      new_match = proc { associated }
-      Puffs::SQLObject.define_singleton_method_by_proc(
-        self, method_name, new_match)
+    attr_reader :klass, :collection, :loaded, :sql_count, :sql_limit
+    attr_accessor :included_relations
 
-      associated
-    end
+    def initialize(options)
+      defaults =
+      {
+        klass: nil,
+        loaded: false,
+        collection: []
+      }
 
-    #we overwrite the association method for each SQLObject in the
-    #collection so that it points to our cached relation and doesn't fire a query.
-    base.collection.each do |b_sql_obj|
-      Puffs::SQLObject.define_singleton_method_by_proc(
-        b_sql_obj, method_name, match)
+      @klass      = options[:klass]
+      @collection = options[:collection] || defaults[:collection]
+      @loaded     = options[:loaded]     || defaults[:loaded]
     end
-  end
 
-  attr_reader :klass, :collection, :loaded, :sql_count, :sql_limit
-  attr_accessor :included_relations
+    def <<(item)
+      if item.class == klass
+        @collection << item
+      end
+    end
 
-  def initialize(options)
-    defaults =
-    {
-      klass: nil,
-      loaded: false,
-      collection: []
-    }
+    def count
+      @sql_count = true
+      load
+    end
 
-    @klass      = options[:klass]
-    @collection = options[:collection] || defaults[:collection]
-    @loaded     = options[:loaded]     || defaults[:loaded]
-  end
+    def included_relations
+      @included_relations ||= []
+    end
 
-  def <<(item)
-    if item.class == klass
-      @collection << item
+    def includes(klass)
+      includes_params << klass
+      self
     end
-  end
 
-  def count
-    @sql_count = true
-    load
-  end
+    def includes_params
+      @includes_params ||= []
+    end
 
-  def included_relations
-    @included_relations ||= []
-  end
+    def limit(n)
+      @sql_limit = n
+      self
+    end
 
-  def includes(klass)
-    includes_params << klass
-    self
-  end
+    def load
+      if !loaded
+        puts "LOADING #{table_name}"
+          results = Puffs::DBConnection.execute(<<-SQL, sql_params[:values])
+          SELECT
+            #{sql_count ? "COUNT(*)" : self.table_name.to_s + ".*"}
+          FROM
+            #{self.table_name}
+          #{sql_params[:where]}
+            #{sql_params[:params]}
+          #{order_by_string}
+          #{"LIMIT #{sql_limit}" if sql_limit};
+        SQL
 
-  def includes_params
-    @includes_params ||= []
-  end
+        results = sql_count ? results.first.values.first : parse_all(results)
+      end
 
-  def limit(n)
-    @sql_limit = n
-    self
-  end
+      results = results || self
 
-  def load
-    if !loaded
-      puts "LOADING #{table_name}"
-        results = DBConnection.execute(<<-SQL, sql_params[:values])
-        SELECT
-          #{sql_count ? "COUNT(*)" : self.table_name.to_s + ".*"}
-        FROM
-          #{self.table_name}
-        #{sql_params[:where]}
-          #{sql_params[:params]}
-        #{order_by_string}
-        #{"LIMIT #{sql_limit}" if sql_limit};
-      SQL
+      unless includes_params.empty?
+        results = load_includes(results)
+      end
 
-      results = sql_count ? results.first.values.first : parse_all(results)
+      results
     end
 
-    results = results || self
+    def load_includes(relation)
+      includes_params.each do |param|
+        if relation.klass.has_association?(param)
+          puts "LOADING #{param.to_s}"
+          assoc = klass.assoc_options[param]
+          f_k = assoc.foreign_key
+          p_k = assoc.primary_key
+          includes_table = assoc.table_name.to_s
+          in_ids = relation.collection.map do |sqlobject|
+            sqlobject.id
+          end.join(", ")
+
+          has_many = assoc.class == HasManyOptions
+
+          results = Puffs::DBConnection.execute(<<-SQL)
+            SELECT
+              #{includes_table}.*
+            FROM
+              #{includes_table}
+            WHERE
+              #{includes_table}.#{has_many ? f_k : p_k}
+            IN
+              (#{in_ids});
+          SQL
+          included = assoc.model_class.parse_all(results)
+          SQLRelation.build_association(relation, included, param)
+        end
+      end
 
-    unless includes_params.empty?
-      results = load_includes(results)
+      relation
     end
 
-    results
-  end
+    def method_missing(method, *args, &block)
+      self.to_a.send(method, *args, &block)
+    end
 
-  def load_includes(relation)
-    includes_params.each do |param|
-      if relation.klass.has_association?(param)
-        puts "LOADING #{param.to_s}"
-        assoc = klass.assoc_options[param]
-        f_k = assoc.foreign_key
-        p_k = assoc.primary_key
-        includes_table = assoc.table_name.to_s
-        in_ids = relation.collection.map do |sqlobject|
-          sqlobject.id
-        end.join(", ")
-
-        has_many = assoc.class == HasManyOptions
-
-        results = DBConnection.execute(<<-SQL)
-          SELECT
-            #{includes_table}.*
-          FROM
-            #{includes_table}
-          WHERE
-            #{includes_table}.#{has_many ? f_k : p_k}
-          IN
-            (#{in_ids});
-        SQL
-        included = assoc.model_class.parse_all(results)
-        Puffs::SQLRelation.build_association(relation, included, param)
+    def order(params)
+      if params.is_a?(Hash)
+        order_params_hash.merge!(params)
+      else
+        order_params_hash.merge!(params => :asc)
       end
+      self
     end
 
-    relation
-  end
-
-  def method_missing(method, *args, &block)
-    self.to_a.send(method, *args, &block)
-  end
-
-  def order(params)
-    if params.is_a?(Hash)
-      order_params_hash.merge!(params)
-    else
-      order_params_hash.merge!(params => :asc)
+    def order_params_hash
+      @order_params_hash ||= {}
     end
-    self
-  end
 
-  def order_params_hash
-    @order_params_hash ||= {}
-  end
+    def order_by_string
+      hash_string = order_params_hash.map do |column, asc_desc|
+        "#{column} #{asc_desc.to_s.upcase}"
+      end.join(", ")
 
-  def order_by_string
-    hash_string = order_params_hash.map do |column, asc_desc|
-      "#{column} #{asc_desc.to_s.upcase}"
-    end.join(", ")
+      hash_string.empty? ? "" : "ORDER BY #{hash_string}"
+    end
 
-    hash_string.empty? ? "" : "ORDER BY #{hash_string}"
-  end
+    def parse_all(attributes)
+      klass.parse_all(attributes).where(where_params_hash).includes(includes_params)
+    end
 
-  def parse_all(attributes)
-    klass.parse_all(attributes).where(where_params_hash).includes(includes_params)
-  end
+    def sql_params
+      params, values = [], []
 
-  def sql_params
-    params, values = [], []
+      i = 1
+      where_params_hash.map do |attribute, value|
+        params << "#{attribute} = $#{i}"
+        values << value
+        i += 1
+      end
 
-    i = 1
-    where_params_hash.map do |attribute, value|
-      params << "#{attribute} = $#{i}"
-      values << value
-      i += 1
+      { params: params.join(" AND "),
+        where: params.empty? ? nil : "WHERE",
+        values: values }
     end
 
-    { params: params.join(" AND "),
-      where: params.empty? ? nil : "WHERE",
-      values: values }
-  end
-
-  def table_name
-    klass.table_name
-  end
+    def table_name
+      klass.table_name
+    end
 
-  def to_a
-    self.load.collection
-  end
+    def to_a
+      self.load.collection
+    end
 
-  def where_params_hash
-    @where_params_hash ||= {}
-  end
+    def where_params_hash
+      @where_params_hash ||= {}
+    end
 
-  def where(params)
-    where_params_hash.merge!(params)
-    self
+    def where(params)
+      where_params_hash.merge!(params)
+      self
+    end
   end
 end

data/lib/router.rb

@@ -1,74 +1,78 @@
-class Route
-  attr_reader :pattern, :http_method, :controller_class, :action_name
+module Puffs
+  # The Puffs Router.
+  class Router
+    attr_reader :routes
 
-  def initialize(pattern, http_method, controller_class, action_name)
-    @pattern = pattern
-    @http_method = http_method
-    @controller_class = controller_class
-    @action_name = action_name
-  end
-
-  # checks if pattern matches path and method matches request method
-  def matches?(req)
-    pattern =~ req.path && req.request_method == http_method.to_s.upcase
-  end
-
-  # use pattern to pull out route params (save for later?)
-  # instantiate controller and call controller action
-  def run(req, res)
-    matches = pattern.match(req.path)
-    route_params = {}
+    def initialize
+      @routes = []
+    end
 
-    matches.names.each do |name|
-      route_params[name] = matches[name]
+    # Adds a new route to the list of routes
+    def add_route(pattern, method, controller_class, action_name)
+      routes << Route.new(pattern, method, controller_class, action_name)
     end
 
-    controller_class.new(req, res, route_params).invoke_action(action_name)
-  end
-end
+    # evaluate the proc in the context of the instance
+    # for syntactic sugar :)
+    def draw(&proc)
+      instance_eval(&proc)
+    end
 
-class Router
-  attr_reader :routes
+    # make each of these methods that
+    # when called add route
+    [:get, :post, :put, :delete].each do |http_method|
+      define_method(http_method) do |pattern, controller_class, action_name|
+        add_route(pattern, http_method, controller_class, action_name)
+      end
+    end
 
-  def initialize
-    @routes = []
-  end
+    # should return the route that matches this request
+    def match(req)
+      routes.each do |route|
+        return route if route.matches?(req)
+      end
+      nil
+    end
 
-  # simply adds a new route to the list of routes
-  def add_route(pattern, method, controller_class, action_name)
-    routes << Route.new(pattern, method, controller_class, action_name)
+    # either throw 404 or call run on a matched route
+    def run(req, res)
+      route = match(req)
+      if route
+        route.run(req, res)
+      else
+        res.status = 404
+        res.body = ["Sorry, Charlie. That page doesn't exist."]
+      end
+    end
   end
 
-  # evaluate the proc in the context of the instance
-  # for syntactic sugar :)
-  def draw(&proc)
-    instance_eval(&proc)
-  end
+  # Router is comprised of Routes.
+  class Route
+    attr_reader :pattern, :http_method, :controller_class, :action_name
 
-  # make each of these methods that
-  # when called add route
-  [:get, :post, :put, :delete].each do |http_method|
-    define_method(http_method) do |pattern, controller_class, action_name|
-      add_route(pattern, http_method, controller_class, action_name)
+    def initialize(pattern, http_method, controller_class, action_name)
+      @pattern = pattern
+      @http_method = http_method
+      @controller_class = controller_class
+      @action_name = action_name
     end
-  end
 
-  # should return the route that matches this request
-  def match(req)
-    routes.each do |route|
-      return route if route.matches?(req)
+    # checks if pattern matches path and method matches request method
+    def matches?(req)
+      pattern =~ req.path && req.request_method == http_method.to_s.upcase
     end
-    nil
-  end
 
-  # either throw 404 or call run on a matched route
-  def run(req, res)
-    route = match(req)
-    if route
-      route.run(req, res)
-    else
-      res.status = 404
-      res.body = ["Sorry, Charlie. That page doesn't exist."]
+    # use pattern to pull out route params (save for later?)
+    # instantiate controller and call controller action
+    def run(req, res)
+      matches = pattern.match(req.path)
+      route_params = {}
+
+      matches.names.each do |name|
+        route_params[name] = matches[name]
+      end
+
+      controller_class.new(req, res, route_params).invoke_action(action_name)
     end
   end
 end

data/lib/server_connection.rb

@@ -1,18 +1,21 @@
 require 'rack'
 require './config/routes'
 
-class ServerConnection
-  def self.start
-    app = Proc.new do |env|
-      req = Rack::Request.new(env)
-      res = Rack::Response.new
-      ROUTER.run(req, res)
-      res.finish
-    end
+module Puffs
+  # Invoked through `puffs server` in CLI.
+  class ServerConnection
+    def self.start
+      app = proc do |env|
+        req = Rack::Request.new(env)
+        res = Rack::Response.new
+        ROUTER.run(req, res)
+        res.finish
+      end
 
-    Rack::Server.start(
-     app: app,
-     Port: 3000
-    )
+      Rack::Server.start(
+        app: app,
+        Port: 3000
+      )
+    end
   end
 end

data/lib/session.rb

@@ -1,28 +1,36 @@
 require 'json'
 
-class Session
-  # find the cookie for this app
-  # deserialize the cookie into a hash
-  def initialize(req)
-    cookie =  req.cookies['_rails_lite_app']
-    if cookie
-       @session_data = JSON.parse(cookie)
-    else
-      @session_data = {}
+module Puffs
+  # Session token.
+  class Session
+    # find the cookie for this app
+    # deserialize the cookie into a hash
+    def initialize(req)
+      cookie = req.cookies['_rails_lite_app']
+
+      if cookie
+        @session_data = JSON.parse(cookie)
+      else
+        @session_data = {}
+      end
     end
-  end
 
-  def [](key)
-    @session_data[key]
-  end
+    def [](key)
+      @session_data[key]
+    end
 
-  def []=(key, val)
-    @session_data[key] = val
-  end
+    def []=(key, val)
+      @session_data[key] = val
+    end
 
-  # serialize the hash into json and save in a cookie
-  # add to the responses cookies
-  def store_session(res)
-    res.set_cookie("_rails_lite_app", { path: '/', value: @session_data.to_json })
+    # serialize the hash into json and save in a cookie
+    # add to the responses cookies
+    def store_session(res)
+      res.set_cookie(
+        '_rails_lite_app',
+        path: '/',
+        value: @session_data.to_json
+      )
+    end
   end
 end