puffs 0.1.1

data/lib/relation.rb

@@ -0,0 +1,206 @@
+require_relative './../lib/db_connection'
+require_relative 'sql_object/sql_object'
+
+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
+
+    match = proc do
+      selection = included.select do |i_sql_obj|
+        i_sql_obj.send(i_send) == self.send(b_send)
+      end
+
+      associated = has_many ? selection : selection.first
+
+      #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 }
+      SQLObject.define_singleton_method_by_proc(
+        self, method_name, new_match)
+
+      associated
+    end
+
+    #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|
+      SQLObject.define_singleton_method_by_proc(
+        b_sql_obj, method_name, match)
+    end
+  end
+
+  attr_reader :klass, :collection, :loaded, :sql_count, :sql_limit
+  attr_accessor :included_relations
+
+  def initialize(options)
+    defaults =
+    {
+      klass: nil,
+      loaded: false,
+      collection: []
+    }
+
+    @klass      = options[:klass]
+    @collection = options[:collection] || defaults[:collection]
+    @loaded     = options[:loaded]     || defaults[:loaded]
+  end
+
+  def <<(item)
+    if item.class == klass
+      @collection << item
+    end
+  end
+
+  def count
+    @sql_count = true
+    load
+  end
+
+  def included_relations
+    @included_relations ||= []
+  end
+
+  def includes(klass)
+    includes_params << klass
+    self
+  end
+
+  def includes_params
+    @includes_params ||= []
+  end
+
+  def limit(n)
+    @sql_limit = n
+    self
+  end
+
+  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
+
+      results = sql_count ? results.first.values.first : parse_all(results)
+    end
+
+    results = results || self
+
+    unless includes_params.empty?
+      results = load_includes(results)
+    end
+
+    results
+  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)
+        SQLRelation.build_association(relation, included, param)
+      end
+    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)
+    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(", ")
+
+    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 sql_params
+    params, values = [], []
+
+    i = 1
+    where_params_hash.map do |attribute, value|
+      params << "#{attribute} = $#{i}"
+      values << value
+      i += 1
+    end
+
+    { params: params.join(" AND "),
+      where: params.empty? ? nil : "WHERE",
+      values: values }
+  end
+
+  def table_name
+    klass.table_name
+  end
+
+  def to_a
+    self.load.collection
+  end
+
+  def where_params_hash
+    @where_params_hash ||= {}
+  end
+
+  def where(params)
+    where_params_hash.merge!(params)
+    self
+  end
+end

data/lib/router.rb

@@ -0,0 +1,77 @@
+project_root = File.dirname(File.absolute_path(__FILE__))
+Dir.glob(project_root + '/../app/controllers/*.rb') { |file| require file }
+
+class Route
+  attr_reader :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
+
+  # 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 = {}
+
+    matches.names.each do |name|
+      route_params[name] = matches[name]
+    end
+
+    controller_class.new(req, res, route_params).invoke_action(action_name)
+  end
+end
+
+class Router
+  attr_reader :routes
+
+  def initialize
+    @routes = []
+  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)
+  end
+
+  # evaluate the proc in the context of the instance
+  # for syntactic sugar :)
+  def draw(&proc)
+    instance_eval(&proc)
+  end
+
+  # 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
+
+  # should return the route that matches this request
+  def match(req)
+    routes.each do |route|
+      return route if route.matches?(req)
+    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."]
+    end
+  end
+end

data/lib/server_connection.rb

@@ -0,0 +1,19 @@
+require 'rack'
+require_relative 'router'
+require_relative '../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
+
+    Rack::Server.start(
+     app: app,
+     Port: 3000
+    )
+  end
+end

data/lib/session.rb

@@ -0,0 +1,28 @@
+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 = {}
+    end
+  end
+
+  def [](key)
+    @session_data[key]
+  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 })
+  end
+end

data/lib/sql_object/associatable.rb

@@ -0,0 +1,97 @@
+require 'active_support/inflector'
+
+class AssocOptions
+  attr_accessor(
+    :foreign_key,
+    :class_name,
+    :primary_key
+  )
+
+  def model_class
+    class_name.constantize
+  end
+
+  def table_name
+    model_class.table_name
+  end
+end
+
+class BelongsToOptions < AssocOptions
+  def initialize(name, options = {})
+    @primary_key = options[:primary_key] || :id
+    @foreign_key = options[:foreign_key] || "#{name}_id".to_sym
+    @class_name = options[:class_name] || name.to_s.capitalize
+  end
+end
+
+class HasManyOptions < AssocOptions
+  def initialize(name, self_class_name, options = {})
+    @primary_key = options[:primary_key] || :id
+    @foreign_key = options[:foreign_key] || "#{self_class_name.to_s.underscore}_id".to_sym
+    @class_name = options[:class_name] || name.to_s.singularize.camelcase
+  end
+end
+
+module Associatable
+  def belongs_to(name, options = {})
+    options = BelongsToOptions.new(name, options)
+    assoc_options[name] = options
+
+    define_method(name) do
+      foreign_key_value = self.send(options.foreign_key)
+      return nil if foreign_key_value.nil?
+
+      options.model_class
+             .where(options.primary_key => foreign_key_value)
+             .first
+    end
+  end
+
+  def has_many(name, options = {})
+    options = HasManyOptions.new(name, self.to_s, options)
+    assoc_options[name] = options
+
+    define_method(name) do
+      target_key_value = self.send(options.primary_key)
+      return nil if target_key_value.nil?
+      options.model_class
+             .where(options.foreign_key => target_key_value)
+             .to_a
+    end
+  end
+
+  def assoc_options
+    @assoc_options ||= {}
+  end
+
+  def has_one_through(name, through_name, source_name)
+    through_options = assoc_options[through_name]
+
+    define_method(name) do
+      source_options =
+        through_options.model_class.assoc_options[source_name]
+      through_pk = through_options.primary_key
+      key_val = self.send(through_options.foreign_key)
+
+      source_options.model_class.includes(through_options.model_class)
+                                .where(through_pk => key_val).first
+    end
+  end
+
+  def has_many_through(name, through_name, source_name)
+    through_options = assoc_options[through_name]
+    define_method(name) do
+      through_fk = through_options.foreign_key
+      through_class = through_options.model_class
+      key_val = self.send(through_options.primary_key)
+
+      #2 queries, we could reduce to 1 by writing SQLRelation::join.
+      through_class.where(through_fk => key_val)
+                   .includes(source_name)
+                   .load
+                   .included_relations
+                   .first
+                   .to_a
+    end
+  end
+end

data/lib/sql_object/sql_object.rb

@@ -0,0 +1,156 @@
+require_relative '../../lib/db_connection'
+require_relative 'associatable'
+require_relative '../relation'
+require 'active_support/inflector'
+
+class SQLObject
+  extend Associatable
+
+  RELATION_METHODS = [
+    :limit, :includes, :where, :order
+  ]
+
+  RELATION_METHODS.each do |method|
+    define_singleton_method(method) do |arg|
+      SQLRelation.new(klass: self).send(method, arg)
+    end
+  end
+
+  def self.all
+    where({})
+  end
+
+  def self.columns
+    DBConnection.columns(table_name)
+  end
+
+  def self.count
+    all.count
+  end
+
+  def self.define_singleton_method_by_proc(obj, name, block)
+    metaclass = class << obj; self; end
+    metaclass.send(:define_method, name, block)
+  end
+
+  def self.destroy_all!
+    self.all.each do |entry|
+      entry.destroy!
+    end
+  end
+
+  def self.finalize!
+    self.columns.each do |column|
+      define_method(column) do
+        attributes[column]
+      end
+
+      define_method("#{column}=") do |new_value|
+        attributes[column] = new_value
+      end
+    end
+  end
+
+  def self.find(id)
+    where(id: id).first
+  end
+
+  def self.first
+    all.limit(1).first
+  end
+
+  def self.has_association?(association)
+    assoc_options.keys.include?(association)
+  end
+
+  def self.last
+    all.order(id: :desc).limit(1).first
+  end
+
+  def self.parse_all(results)
+    relation = SQLRelation.new(klass: self, loaded: true)
+    results.each do |result|
+      relation << self.new(result)
+    end
+
+    relation
+  end
+
+  def self.table_name=(table_name)
+    @table_name = table_name
+  end
+
+  def self.table_name
+    @table_name ||= self.to_s.downcase.tableize
+  end
+
+  def initialize(params = {})
+    params.each do |attr_name, value|
+      unless self.class.columns.include?(attr_name.to_sym)
+        raise "unknown attribute '#{attr_name}'"
+      end
+
+      self.send("#{attr_name}=", value)
+    end
+  end
+
+  def attributes
+    @attributes ||= {}
+  end
+
+  def attribute_values
+    self.class.columns.map do |column|
+      self.send(column)
+    end
+  end
+
+  def destroy!
+    if self.class.find(id)
+      DBConnection.execute(<<-SQL)
+        DELETE
+        FROM
+          #{self.class.table_name}
+        WHERE
+          id = #{id}
+      SQL
+      return self
+    end
+  end
+
+  def insert
+    columns = self.class.columns.reject { |col| col == :id }
+    column_values = columns.map {|attr_name| send(attr_name)}
+    column_names = columns.join(", ")
+    bind_params = (1..columns.length).map {|n| "$#{n}"}.join(", ")
+    result = DBConnection.execute(<<-SQL, column_values)
+      INSERT INTO
+        #{self.class.table_name} (#{column_names})
+      VALUES
+        (#{bind_params})
+        RETURNING id;
+    SQL
+    self.id = result.first['id']
+    self
+  end
+
+  def save
+    self.class.find(id) ? update : insert
+  end
+
+  def update
+    set_line = self.class.columns.map do |column|
+      #bobby tables says hi!
+      "#{column} = \'#{self.send(column)}\'"
+    end.join(", ")
+
+    DBConnection.execute(<<-SQL)
+      UPDATE
+        #{self.class.table_name}
+      SET
+        #{set_line}
+      WHERE
+        id = #{id}
+    SQL
+    self
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Puffs
+  VERSION = "0.1.1"
+end

data/puffs.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "puffs"
+  spec.version       = Puffs::VERSION
+  spec.authors       = ["Zachary Moroni"]
+  spec.email         = ["zachary.moroni@gmail.com"]
+
+  spec.summary       = %q{A simple ORM and MVC inspired by Rails.}
+  spec.description   = %q{Coming Soon...}
+  spec.homepage      = "http://github.com/snackzone"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end