puffs 0.2.05 → 0.2.06

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c18567a1d51b75d3ad758258c55923663e43bd96
-  data.tar.gz: 35baf154d55ce813ad53d2b260c78a36b3925b14
+  metadata.gz: ffc8090b37bd60c44f6e9ab1c3b03a13efdd8245
+  data.tar.gz: ee5f09a1613a4536a6ce8e22bae477d532b5b94e
 SHA512:
-  metadata.gz: 2e2c6e55a65a3aac467c51b21a93cc845489926d3c33186d6e311533bfdff2fc316ba9c2648a131127ff21cccbf76627b4c35dcbe2d977a20895272fa6be94c2
-  data.tar.gz: 6a7c885f4e2e91700482a70d8ebe6447f55fea35fb4ed36ee498281439dd1f2b42d1d9ff4d36a7b18a4d1ebc2091da80ab43355d637c3fe2d627edc06efc5c9e
+  metadata.gz: 29c2b60efd307a57c81242884f8285d17496fdbec2363063132d28b9b0315b5dfcfbcf7d3694c0c68dd4f450c785849ef9b36e606f7e80cde6c1bb18d7a7c27d
+  data.tar.gz: 37f8b2b9207f48566161989d72892203640cae3fa92b2f544f1ccd1cb8d0344c802b5f2e7d0dd8b0404ca8e5bc1817f10616ae87520aa68575d8582319c51773

data/lib/relation.rb

@@ -1,7 +1,5 @@
-require_relative './../lib/db_connection'
-require_relative 'sql_object/sql_object'
-
 module Puffs
+  # Queries made through Puffs::SQLObject return instance of SQLRelation
   class SQLRelation
     def self.build_association(base, included, method_name)
       base.included_relations << included
@@ -19,13 +17,13 @@ module Puffs
 
       match = proc do
         selection = included.select do |i_sql_obj|
-          i_sql_obj.send(i_send) == self.send(b_send)
+          i_sql_obj.send(i_send) == 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).
+        # 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)
@@ -33,8 +31,9 @@ module Puffs
         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.
+      # 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)
@@ -46,21 +45,20 @@ module Puffs
 
     def initialize(options)
       defaults =
-      {
-        klass: nil,
-        loaded: false,
-        collection: []
-      }
+        {
+          loaded: false,
+          collection: []
+        }
+
+      merged_options = defaults.merge(options)
 
       @klass      = options[:klass]
-      @collection = options[:collection] || defaults[:collection]
-      @loaded     = options[:loaded]     || defaults[:loaded]
+      @collection = merged_options[:collection]
+      @loaded     = merged_options[:loaded]
     end
 
     def <<(item)
-      if item.class == klass
-        @collection << item
-      end
+      @collection << item if item.class == klass
     end
 
     def count
@@ -87,13 +85,13 @@ module Puffs
     end
 
     def load
-      if !loaded
+      unless loaded
         puts "LOADING #{table_name}"
-          results = Puffs::DBConnection.execute(<<-SQL, sql_params[:values])
+        results = Puffs::DBConnection.execute(<<-SQL, sql_params[:values])
           SELECT
-            #{sql_count ? "COUNT(*)" : self.table_name.to_s + ".*"}
+            #{sql_count ? 'COUNT(*)' : table_name.to_s + '.*'}
           FROM
-            #{self.table_name}
+            #{table_name}
           #{sql_params[:where]}
             #{sql_params[:params]}
           #{order_by_string}
@@ -103,56 +101,49 @@ module Puffs
         results = sql_count ? results.first.values.first : parse_all(results)
       end
 
-      results = results || self
-
-      unless includes_params.empty?
-        results = load_includes(results)
-      end
-
+      results ||= self
+      results = load_includes(results) unless includes_params.empty?
       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 = 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
+        next unless relation.klass.has_association?(param)
+
+        puts "LOADING #{param}"
+        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(&:id).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
 
       relation
     end
 
     def method_missing(method, *args, &block)
-      self.to_a.send(method, *args, &block)
+      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)
+        order_params_hash[params] = :asc
       end
       self
     end
@@ -164,17 +155,20 @@ module Puffs
     def order_by_string
       hash_string = order_params_hash.map do |column, asc_desc|
         "#{column} #{asc_desc.to_s.upcase}"
-      end.join(", ")
+      end.join(', ')
 
-      hash_string.empty? ? "" : "ORDER BY #{hash_string}"
+      hash_string.empty? ? '' : "ORDER BY #{hash_string}"
     end
 
     def parse_all(attributes)
-      klass.parse_all(attributes).where(where_params_hash).includes(includes_params)
+      klass.parse_all(attributes)
+           .where(where_params_hash)
+           .includes(includes_params)
     end
 
     def sql_params
-      params, values = [], []
+      params = []
+      values = []
 
       i = 1
       where_params_hash.map do |attribute, value|
@@ -183,8 +177,8 @@ module Puffs
         i += 1
       end
 
-      { params: params.join(" AND "),
-        where: params.empty? ? nil : "WHERE",
+      { params: params.join(' AND '),
+        where: params.empty? ? nil : 'WHERE',
         values: values }
     end
 
@@ -193,7 +187,7 @@ module Puffs
     end
 
     def to_a
-      self.load.collection
+      load.collection
     end
 
     def where_params_hash

data/lib/sql_object/associatable.rb

@@ -1,99 +1,119 @@
 require 'active_support/inflector'
 
-module Puffs
-  class AssocOptions
-    attr_accessor(
-      :foreign_key,
-      :class_name,
-      :primary_key
-    )
-
-    def model_class
-      class_name.constantize
-    end
+# Used in HasManyOptions and BelongsToOptions
+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
+  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
+# Used to build belongs_to associations.
+class BelongsToOptions < AssocOptions
+  def initialize(name, options = {})
+    defaults = {
+      primary_key: :id,
+      foreign_key: "#{name}_id".to_sym,
+      class_name: name.to_s.capitalize
+    }
+
+    merged_options = defaults.merge(options)
+
+    @primary_key = merged_options[:primary_key]
+    @foreign_key = merged_options[:foreign_key]
+    @class_name = merged_options[:class_name]
   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
+# Used to build has_many associations.
+class HasManyOptions < AssocOptions
+  def initialize(name, self_class_name, options = {})
+    defaults = {
+      primary_key: :id,
+      foreign_key: "#{self_class_name.to_s.underscore}_id".to_sym,
+      class_name: name.to_s.singularize.camelcase
+    }
+
+    merged_options = defaults.merge(options)
+
+    @primary_key = merged_options[:primary_key]
+    @foreign_key = merged_options[:foreign_key]
+    @class_name = merged_options[:class_name]
   end
+end
 
-  module Associatable
-    def belongs_to(name, options = {})
-      options = BelongsToOptions.new(name, options)
-      assoc_options[name] = options
+# Used to map association methods.
+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?
+    define_method(name) do
+      foreign_key_value = send(options.foreign_key)
+      return nil if foreign_key_value.nil?
 
-        options.model_class
-               .where(options.primary_key => foreign_key_value)
-               .first
-      end
+      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 has_many(name, options = {})
+    options = HasManyOptions.new(name, to_s, options)
+    assoc_options[name] = options
 
-    def assoc_options
-      @assoc_options ||= {}
+    define_method(name) do
+      target_key_value = 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]
+  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)
+    define_method(name) do
+      source_options =
+        through_options.model_class.assoc_options[source_name]
+      through_pk = through_options.primary_key
+      key_val = send(through_options.foreign_key)
 
-        source_options.model_class.includes(through_options.model_class)
-                                  .where(through_pk => key_val).first
-      end
+      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 Puffs::SQLRelation.join.
-        through_class.where(through_fk => key_val)
-                     .includes(source_name)
-                     .load
-                     .included_relations
-                     .first
-                     .to_a
-      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 = send(through_options.primary_key)
+
+      # 2 queries, we could reduce to 1 by writing Puffs::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/searchable.rb

@@ -0,0 +1,32 @@
+# Search methods for Puffs::SQLObject
+module Searchable
+  RELATION_METHODS = [
+    :limit, :includes, :where, :order
+  ].freeze
+
+  RELATION_METHODS.each do |method|
+    define_method(method) do |arg|
+      Puffs::SQLRelation.new(klass: self).send(method, arg)
+    end
+  end
+
+  def all
+    where({})
+  end
+
+  def count
+    all.count
+  end
+
+  def find(id)
+    where(id: id).first
+  end
+
+  def first
+    all.limit(1).first
+  end
+
+  def last
+    all.order(id: :desc).limit(1).first
+  end
+end

data/lib/sql_object/sql_object.rb

@@ -1,48 +1,30 @@
+require 'active_support/inflector'
 require_relative '../../lib/db_connection'
 require_relative 'associatable'
 require_relative '../relation'
-require 'active_support/inflector'
-# require_relative '../puffs'
+require_relative 'searchable'
 
 module Puffs
+  # Base Model class for Puffs Orm.
   class SQLObject
     extend Associatable
-
-    RELATION_METHODS = [
-      :limit, :includes, :where, :order
-    ]
-
-    RELATION_METHODS.each do |method|
-      define_singleton_method(method) do |arg|
-        Puffs::SQLRelation.new(klass: self).send(method, arg)
-      end
-    end
-
-    def self.all
-      where({})
-    end
+    extend Searchable
 
     def self.columns
       Puffs::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
+      all.each(&:destroy!)
     end
 
     def self.finalize!
-      self.columns.each do |column|
+      columns.each do |column|
         define_method(column) do
           attributes[column]
         end
@@ -53,26 +35,14 @@ module Puffs
       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 = Puffs::SQLRelation.new(klass: self, loaded: true)
       results.each do |result|
-        relation << self.new(result)
+        relation << new(result)
       end
 
       relation
@@ -83,7 +53,7 @@ module Puffs
     end
 
     def self.table_name
-      @table_name ||= self.to_s.downcase.tableize
+      @table_name ||= to_s.downcase.tableize
     end
 
     def initialize(params = {})
@@ -92,7 +62,7 @@ module Puffs
           raise "unknown attribute '#{attr_name}'"
         end
 
-        self.send("#{attr_name}=", value)
+        send("#{attr_name}=", value)
       end
     end
 
@@ -102,7 +72,7 @@ module Puffs
 
     def attribute_values
       self.class.columns.map do |column|
-        self.send(column)
+        send(column)
       end
     end
 
@@ -121,9 +91,9 @@ module Puffs
 
     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(", ")
+      column_values = columns.map { |attr_name| send(attr_name) }
+      column_names = columns.join(', ')
+      bind_params = (1..columns.length).map { |n| "$#{n}" }.join(', ')
       result = Puffs::DBConnection.execute(<<-SQL, column_values)
         INSERT INTO
           #{self.class.table_name} (#{column_names})
@@ -141,8 +111,8 @@ module Puffs
 
     def update
       set_line = self.class.columns.map do |column|
-        "#{column} = \'#{self.send(column)}\'"
-      end.join(", ")
+        "#{column} = \'#{send(column)}\'"
+      end.join(', ')
 
       Puffs::DBConnection.execute(<<-SQL)
         UPDATE

data/puffs.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'puffs'
-  spec.version       = '0.2.05'
+  spec.version       = '0.2.06'
   spec.authors       = ['Zachary Moroni']
   spec.email         = ['zachary.moroni@gmail.com']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puffs
 version: !ruby/object:Gem::Version
-  version: 0.2.05
+  version: 0.2.06
 platform: ruby
 authors:
 - Zachary Moroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-25 00:00:00.000000000 Z
+date: 2016-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -186,6 +186,7 @@ files:
 - lib/server_connection.rb
 - lib/session.rb
 - lib/sql_object/associatable.rb
+- lib/sql_object/searchable.rb
 - lib/sql_object/sql_object.rb
 - puffs.gemspec
 - readme.md