familyable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c05a813418d27a79b6a38a33d303ad1bd02e551d
+  data.tar.gz: 275d41cb50d00fb8f0a3512e712fb0fa979f9593
+SHA512:
+  metadata.gz: ef6d2919bc506784be2d4b4b8770817994f10bebf506e2e0d3bdc1e41875444c6d41cfde7d04c87880efe02e15bd0f803efbd07c0273bbe5d8fdf78eeb1ea61a
+  data.tar.gz: b0bf6eb658ef5b07c1f802900f7db5a176c1edbd20be0e5916f75401551b9a763612b2fc534ed1d30efaffdadc1934b024dc2f4c234deb82dd33ca0beaa64c72

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+### Familyable
+
+This gem makes creating self-referential parent child relationships on a model easy. So for a `Person` model you have `person.parent` and `person.children` where the parent and children are also people.
+
+You also get the following instance methods:
+
+* descendents
+* elders
+* siblings
+* family    
+* master  *- the 'oldest' in the family*
+
+and the class method:
+
+* masters *- everyone without a parent*
+
+Standard stuff I know but...
+##### Everyone of the methods above works with a single call to the data base!!!
+
+This is a **[huge](https://github.com/brookisme/familyable-testapp)** performance gain.  In fact, being able build the above methods with a single database call was the entire motivation for gemifiying something that otherwise was entirely straight forward.  It should be noted that this was built the day after reading [this](http://hashrocket.com/blog/posts/recursive-sql-in-activerecord).
+
+-----------------------------------------------------------
+
+##### WARNING: This project is still in development
+    [x] create relationship concern
+    [X] create generators for relationship models
+    [X] check that it works with engines
+    [ ] generate data for testapp
+    [ ] tests tests tests
+    [ ] refactor concern
+    [ ] add babies methods (class and instance)?
+
+
+### Requirments
+
+You must be using a postgres data base... thats where the single-db-query magic happens.
+
+### Installation
+
+familyable gem will be comming soon for now get it from this repo.. actually its too soon to use it - but soon!!!
+
+### Usage
+
+-----------------------------------------------------------
+
+Example: Adding Relationships to an existing `Person` model:
+
+##### Step 1: Generate Relationship Model
+
+```
+$  bundle exec rails g familyable:relationships Person
+$  bundle exec rake db:migrate
+```
+
+Note: For use with Rails Engines use the full model name from the the root of your Engine directory.
+
+```
+$  bundle exec rails g familyable:relationships MyEngine::Person
+```
+
+
+##### Step 2: Add Relationships Concern to Model
+
+_app/models/person.rb_
+```ruby
+class Person < ActiveRecord::Base
+    include Familyable::Relationships
+    ...
+end
+```
+
+##### Step 3: You're done! start coding
+
+quick note: all the instance methods above (accept for master) take an optional parameter *include\_self=false*.  it does what you exactly what you think.
+
+```ruby
+Person.masters
+person.master
+person.descendents
+person.descendents(true)
+...
+```

data/Rakefile

@@ -0,0 +1,21 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Familyable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/lib/familyable/concerns/relationships.rb

@@ -0,0 +1,258 @@
+module Familyable
+  module Relationships
+  extend ActiveSupport::Concern
+
+
+
+    included do
+      has_many relationships_name.to_sym
+      has_many :children, through: relationships_name.to_sym
+      has_one inv_relationships_name.to_sym, class_name: relationship_class_name, foreign_key: "child_id"
+      has_one :parent, through: inv_relationships_name.to_sym, source: model_name.to_sym   
+    end
+    
+    # *****************************
+    #
+    # Main Interface
+    #
+    # *****************************
+
+    module ClassMethods
+      def masters
+        where(without_parents_where_sql)
+      end
+    end
+
+    def master
+      call = elders
+      call.where(klass.without_parents_where_sql).first
+    end
+
+    def descendents include_self=false
+      query_call(
+        "#{table_name}.id IN (#{descendents_sql_list})",
+        include_self
+      )
+    end
+    
+    def elders include_self=false
+      query_call(
+        "#{table_name}.id IN (#{elders_sql_list})",
+        include_self
+      )
+    end
+
+    def siblings include_self=false
+      query_call(
+        "#{table_name}.id IN (#{siblings_sql_list})",
+        include_self
+      )      
+    end
+
+    def family include_self=false
+      query_call(
+        "#{table_name}.id IN (#{family_sql_list})",
+        include_self
+      )
+    end
+
+    # *****************************
+    #
+    # Utilities
+    #
+    # *****************************
+
+    module ClassMethods
+
+      #
+      # ID LISTS
+      #
+
+      def children_of(id_sql)
+        id_sql = safe_identifier(id_sql)
+        tree_sql =  <<-SQL
+          SELECT DISTINCT #{relationship_table_name}.child_id 
+          FROM #{table_name}
+          JOIN #{relationship_table_name} 
+          ON #{table_name}.id = #{relationship_table_name}.#{parent_field_name}
+          WHERE #{table_name}.id = #{id_sql}
+        SQL
+      end
+
+      def descendents_of(id_sql)
+        id_sql = safe_identifier(id_sql)
+        tree_sql =  <<-SQL
+          WITH RECURSIVE search_tree(id, path) AS (
+              SELECT id, ARRAY[id]
+              FROM #{table_name}
+              WHERE id = #{id_sql}
+            UNION ALL
+              SELECT #{table_name}.id, path || #{table_name}.id
+              FROM search_tree
+              JOIN #{relationship_table_name} ON #{relationship_table_name}.#{parent_field_name} = search_tree.id
+              JOIN #{table_name} ON #{table_name}.id = #{relationship_table_name}.child_id
+              WHERE NOT #{table_name}.id = ANY(path)
+          )
+          SELECT id FROM search_tree ORDER BY path
+        SQL
+      end
+
+      def elders_of(id_sql)
+        id_sql = safe_identifier(id_sql)
+        tree_sql =  <<-SQL
+          WITH RECURSIVE search_tree(id, path) AS (
+              SELECT id, ARRAY[id]
+              FROM #{table_name}
+              WHERE id = #{id_sql}
+            UNION ALL
+              SELECT #{table_name}.id, path || #{table_name}.id
+              FROM search_tree
+              JOIN #{relationship_table_name} ON #{relationship_table_name}.child_id = search_tree.id
+              JOIN #{table_name} ON #{table_name}.id = #{relationship_table_name}.#{parent_field_name}
+              WHERE NOT #{table_name}.id = ANY(path)
+          )
+          SELECT id FROM search_tree ORDER BY path
+        SQL
+      end
+
+      def without_parents_where_sql
+        "#{table_name}.id NOT IN (
+          SELECT DISTINCT #{relationship_table_name}.child_id
+          FROM #{relationship_table_name}
+        )"
+      end
+
+      #
+      # UTILS
+      #
+
+      def relationship_table_name
+        if @relationship_table_name.nil?
+           @relationship_table_name = "#{table_name.singularize}_relationships"
+        end
+        @relationship_table_name
+      end
+
+      def relationship_class_name
+       if @relationship_class_name.nil?
+           @relationship_class_name = "#{self.name.split("::").last}Relationship"
+        end
+        @relationship_class_name
+      end
+
+      def model_name
+       if @model_name.nil?
+           @model_name = "#{self.name.split("::").last.downcase}"
+        end
+        @model_name
+      end
+
+      def relationships_name
+       if @relationships_name.nil?
+           @relationships_name = "#{self.name.split("::").last.downcase}_relationships"
+        end
+        @relationships_name
+      end
+
+      def inv_relationships_name
+       if @inv_relationships_name.nil?
+           @inv_relationships_name = "inverse_#{relationships_name}"
+        end
+        @inv_relationships_name
+      end
+
+      def parent_field_name
+        if @parent_field_name.nil?
+           @parent_field_name = "#{self.name.split("::").last.downcase}_id"
+        end
+        @parent_field_name
+      end
+
+      def safe_identifier id_sql
+        if id_sql.to_i == 0
+          "(#{id_sql})"
+        else
+          id_sql
+        end
+      end
+    end
+
+
+  private
+
+    #
+    #  SQL LISTS
+    #
+  
+    def descendents_sql_list
+      klass.descendents_of(id)
+    end
+
+    def elders_sql_list
+      klass.elders_of(id)
+    end
+
+    def siblings_sql_list
+      klass.children_of(select_parent_sql)
+    end
+
+    def family_sql_list
+      klass.descendents_of(select_master_sql)
+    end
+
+    #
+    #  SQL
+    #
+
+    def select_parent_sql
+      "SELECT #{relationship_table_name}.#{parent_field_name} 
+      FROM #{klass.table_name}
+      JOIN #{relationship_table_name}
+      ON #{klass.table_name}.id = #{relationship_table_name}.#{parent_field_name}
+      WHERE #{relationship_table_name}.child_id = #{id}
+      LIMIT 1"
+    end
+
+
+    def select_master_sql
+      select_from_sql_list_and(klass.elders_of(id),klass.without_parents_where_sql)
+    end
+
+    #
+    # Utils
+    #
+
+    def query_call(where_sql,include_self=false)
+      call = self.class.where(where_sql)
+      call = call.where.not(id: id) unless include_self
+      call    
+    end
+
+    def klass
+      @klass ||= self.class
+    end
+
+    def table_name
+      @table_name ||= klass.table_name
+    end
+
+    def relationship_table_name
+      @relationship_table_name ||= klass.relationship_table_name
+    end
+
+    def parent_field_name
+      @parent_field_name ||= klass.parent_field_name
+    end
+
+    def select_from_sql_list_and(sql_list,and_sql)
+      "SELECT #{klass.table_name}.id FROM #{klass.table_name} 
+      WHERE (
+        #{klass.table_name}.id IN ( 
+          #{sql_list}
+        )
+      ) AND (
+        #{and_sql}
+      )"
+    end
+  end
+end

data/lib/familyable/version.rb

@@ -0,0 +1,3 @@
+module Familyable
+  VERSION = "0.0.1"
+end

data/lib/familyable.rb

@@ -0,0 +1,3 @@
+require 'familyable/concerns/relationships.rb'
+module Familyable
+end

data/lib/generators/familyable/generator.rb

@@ -0,0 +1,54 @@
+require 'rails/generators'
+module Familyable
+  class Generator < Rails::Generators::Base
+    desc "Shared options and methods for Familyable Generators"
+    
+    argument :model_name, type: :string, required: true, desc: "model name"    
+
+  private
+
+    def model_class_name
+      @model_name.camelize
+    end
+
+    def clean_model_class_name
+      model_class_name.split("::").last
+    end
+
+    def engine_name
+      parts = model_class_name.split("::")
+      if parts.length > 1
+        parts.pop()
+        parts.join("::")
+      end
+    end
+
+    def model_base_name
+      @model_name.underscore
+    end
+
+    def clean_model_base_name
+      model_base_name.split("/").last
+    end
+
+    def relationship_class_name
+      "#{model_class_name}Relationship"
+    end
+
+    def clean_relationship_class_name
+      "#{clean_model_class_name}Relationship"
+    end
+
+    def app_root_path
+      if engine_name.nil?
+        "#{Rails.root}"
+      else
+        "#{engine_name.constantize::Engine.root}"
+      end
+    end
+
+    def relationship_model_path
+      "#{app_root_path}/app/models/#{relationship_class_name.underscore}.rb"
+    end
+  end
+end

data/lib/generators/familyable/relationships_generator.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'generator')
+module Familyable
+  class RelationshipsGenerator < Familyable::Generator
+    desc "Options and methods for Familyable::Relationship"
+    
+    argument :model_name, type: :string, required: true, desc: "model name"    
+    class_option :delete, type: :boolean, required: false, default: false, desc: "delete relationship for model: defaut=false"
+
+    def generate_relationships
+      if options[:delete]
+        system("bundle exec rails d model #{clean_relationship_class_name}")
+      else
+        generate "model", "#{clean_relationship_class_name} #{clean_model_base_name}:references child:references"
+      end
+    end
+
+    def add_class_name
+      unless options[:delete]
+        gsub_file(relationship_model_path, "belongs_to :child", "belongs_to :child, class_name:\"#{clean_model_class_name}\"") 
+      end
+    end
+  end
+end

data/lib/tasks/familyable.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :familyable do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: familyable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brook Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem for creating self-referential parent child relationships on a model
+email:
+- brook.williams@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/familyable.rb
+- lib/familyable/concerns/relationships.rb
+- lib/familyable/version.rb
+- lib/generators/familyable/generator.rb
+- lib/generators/familyable/relationships_generator.rb
+- lib/tasks/familyable.rake
+homepage: http://stickandlogdesigns.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A gem for creating self-referential parent child relationships on a model
+test_files: []