taxonomite 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 23b3b1dfb04a5bba6964518d64495f5ce765a401
+  data.tar.gz: 8b97678d947fb2f0fea89b2298885bad97e01f61
+SHA512:
+  metadata.gz: ab087ff6284c6b3208d6dc1be6b64aa6cd47c0464f5dbc9cd3abc4074f8fdfdd7c0685118350b98393bbb5f42534b7a042d47211927b778a36cf4b33427dfc34
+  data.tar.gz: 263d4a6ca733fad72e9074e6c852f4d36da4a00324c85523671ffa8a246c97c3982b3a193f96c01a40a40a9031d79dc5f1407040f0a4f8c7ecba740d6c8883ce

data/Rakefile

@@ -0,0 +1,30 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+  require 'bundler/gem_tasks'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+
+# APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+
+Bundler::GemHelper.install_tasks
+#Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'documentation']
+end
+
+# RDoc tasks
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Places'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :spec

data/lib/taxonomite.rb

@@ -0,0 +1,6 @@
+require 'taxonomite/node'
+require 'taxonomite/entity'
+
+# Taxonomite module
+module Taxonomite
+end

data/lib/taxonomite/entity.rb

@@ -0,0 +1,39 @@
+# entity.rb
+
+require 'active_support/concern'
+
+module Taxonomite
+  module Entity
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :taxonomy_node, class_name: 'Taxonomite::Node', as: :owner, validate: true
+      before_save :do_setup
+
+      class_eval "def base_class; ::#{self.name}; end"
+    end
+
+    def get_taxonomy_node
+      if (self.taxonomy_node == nil)
+        self.taxonomy_node = self.create_taxonomy_node
+      end
+      self.taxonomy_node
+    end
+
+    protected
+      # classes overload to create the appropriate taxonomy_node
+      # def create_taxonomy_node
+      #   Taxonomite::Node.new(name: self.name)
+      # end
+
+    private
+      # subclasses should overload create_taxonomy_node to create the appropriate Place object and set it up
+      def do_setup
+        if (self.taxonomy_node == nil)
+          self.taxonomy_node = self.respond_to?(:create_taxonomy_node) ? self.create_taxonomy_node : Taxonomite::Node.new(name: self.name)
+          self.taxonomy_node.owner = self
+        end
+      end
+
+  end # module Location
+end # module Places

data/lib/taxonomite/exceptions.rb

@@ -0,0 +1,7 @@
+# taxonomite/exceptions.rb
+
+module Taxonomite
+  class InvalidChild < RuntimeError; end
+  class InvalidParent < RuntimeError; end
+  class CircularRelation < RuntimeError; end
+end # taxonomite

data/lib/taxonomite/node.rb

@@ -0,0 +1,158 @@
+require 'taxonomite/taxonomite_configuration'
+require 'taxonomite/tree'
+
+module Taxonomite
+  class Node
+    # Class declarations
+    #
+    # configuration
+    #
+    # !! note that configuration is class-wide, rather than on an
+    #    instance-instance value; this could be changed, for example if
+    #    two simultaneous persistence models for the place were desired
+    #
+    class << self
+        attr_writer :configiration
+    end
+
+    def self.config
+        @configuration ||= Taxonomite::Configuration.new
+    end
+
+    def self.configure
+        yield(config)
+    end
+
+    def self.reset
+        @configuration = Taxonomite::Configuration.new
+    end
+
+    def self.primary_key
+      "_id"
+    end
+
+    case Node.config.use_tree_model
+    when :self
+      include ::Mongoid::Document
+      include Taxonomite::Tree
+
+      # configure the way the tree behaves
+      before_destroy :nullify_children
+    else
+      raise RuntimeError, 'Invalid option for Node.config.use_tree_model: #{Node.config.use_tree_model}'
+    end
+
+    field :name, type: String         # name of this particular object (not really node)
+    field :description, type: String  # description of this item
+    field :entity_type, type: String, default: ->{ self.get_entity_type }  # type of entity (i.e. state, county, city, etc.)
+
+    belongs_to :owner, polymorphic: true # this is the associated object
+
+    ## Data collection methods
+
+    # aggregates the results of calling method m on all leaves of the tree and returns that
+    def aggregate_leaves(m)
+      if self.leaf?
+        return self.owner.instance_eval(m) if self.owner != nil && self.owner.respond_to?(m)
+        return self.instance_eval(m) if self.respond_to?(m)
+        return 0
+      else
+        res = 0
+        self.children.each do |c|
+          res = res + c.aggregate_leaves(m)
+        end
+        return res
+      end
+    end
+
+    ## Typeification methods
+
+    # typeify name w entity (i.e. 'Washington state' vs. 'Seattle')
+    def typeifiedname
+      s = self.name
+      s += (" " + self.entity_type.capitalize) if self.includetypeinname?
+      return s
+    end
+
+    # subclasses should override to make sure the parent is appropriate for this child
+    # !! could move this to the tree structure
+    def is_valid_parent?(pa)
+        # !! need to figure out how to do this with regexp
+        unless self.invalid_parent_types.include?(pa.entity_type)
+          s = self.valid_parent_types
+          if s.include?('*')
+            return true
+          else
+            return s.include?(pa.entity_type)
+          end
+        else
+          return false
+        end
+    end
+
+    # check for validity, with adding error checking this would be the appropriate
+    # place to add exceptions, etc. (to allow recovery);
+    # !! could move this to the tree structure
+    def is_valid_child?(ch)
+        # !! need to figure out how to do this with regexp
+        unless self.invalid_child_types.include?(ch.entity_type)
+          s = self.valid_child_types
+          if s.include?('*') || s.include?(ch.entity_type)
+            return ch.is_valid_parent?(self)
+          else
+            return false
+          end
+        else
+          return false
+        end
+    end
+
+    # default parent types (subclasses should override as needed) - default specifies any
+    def valid_parent_types
+      '*'
+    end
+
+    # default child types (subclasses should override as needed) - default specifies any
+    def valid_child_types
+      '*'
+    end
+
+    # default invalid child types
+    def invalid_child_types
+      ""
+    end
+
+    # default invalid parent types
+    def invalid_parent_types
+      ""
+    end
+
+    # don't want to index off of place name? - could have multiple entries w. similar names
+    # create an index off of the place name, alone; will later create on off of the
+    # geo locations *additionally*
+    # index({ place_name: 1 }, { unique: false, name: "name_index"})
+
+    # ** would like to hide these interfaces in a private/protected manner, not clear
+    # ** how to do this in Ruby - doesn't have 'const' access similar to c++, etc.
+    protected
+
+        # include type in the name of this place (i.e. 'Washington state')
+        def includetypeinname?
+          return false
+        end
+
+        # set the entity type (each subclass should override)
+        def get_entity_type
+          'Node'
+        end
+
+        def validate_child(ch)
+          raise InvalidChild, "Cannot add #{ch.name} (#{ch.entity_type}) as child of #{self.name} (#{self.entity_type})" if !is_valid_child?(ch)
+        end
+
+        def validate_parent(pa)
+          raise InvalidParent, "Cannot add #{pa.name} (#{pa.enity_type}) as parent of #{self.name} (#{self.entity_type})" if !is_valid_parent?(pa)
+        end
+
+  end   # class Node
+end # module Taxonomite

data/lib/taxonomite/taxonomite_configuration.rb

@@ -0,0 +1,17 @@
+# taxonomite_configuration.rb
+#   hold configuration parameters for the library
+#
+
+module Taxonomite
+    class Configuration
+        # future versions may extend to using different tree models
+        # - for now uses a custom tree model (:self)
+        attr_accessor   :use_tree_model
+
+    protected
+        # initialize
+        def initialize
+            @use_tree_model = :self
+        end
+    end
+end

data/lib/taxonomite/tree.rb

@@ -0,0 +1,130 @@
+# taxonomite_tree.rb
+
+require 'active_support/concern'
+require 'taxonomite/exceptions'
+
+module Taxonomite
+  module Tree
+    extend ActiveSupport::Concern
+
+    # this is what will be included in the class that uses this
+    #
+    included do
+      has_many :children, :class_name => self.name, :inverse_of => :parent, :before_add => :validate_child!
+      belongs_to :parent, :class_name => self.name, :inverse_of => :children
+
+      # this allows for faster database searchign when adding/checking validity
+      # !! not implemented  field :parent_ids, :type => Array, :default => []
+
+      class_eval "def base_class; ::#{self.name}; end"
+    end
+
+    module ClassMethods
+      # find all roots for this tree (Mongoid query)
+      def roots
+        where(:parent_id => nil)
+      end
+
+      # find all leaves fro this tree (Mongoid query)
+      def leaves
+        where(:_id.nin => only(:parent_id).collect(&:parent_id))
+      end
+    end
+
+    # is this a root node?
+    def root?
+      self.parent == nil
+    end
+
+    # is this a leaf?
+    def leaf?
+      self.children.empty?
+    end
+
+    # find the root of this node
+    def root
+      self.root? ? self : self.parent.root
+    end
+
+    # is the object an ancestor of nd?
+    def is_ancestor?(nd)
+      self.root? ? false : (self.parent == nd || self.parent.is_ancestor?(nd))
+    end
+
+    # is this an ancestor of another node?
+    def ancestor_of?(nd)
+      nd.is_ancestor?(self)
+    end
+
+    # is this a descendant of nd?
+    def descendant_of?(nd)
+      (self == nd) ? true : is_ancestor?(nd)
+    end
+
+    # return a chainable Mongoid criteria to get all descendants
+    def descendants
+      doc = Array.new
+      children.each do |c|
+        doc += [c] + c.descendants
+      end
+      return doc
+    end
+
+    # return a chainable Mongoid criteria to get self + all descendants
+    def self_and_descendants
+      [self] + self.descendants
+    end
+
+    # nullifies all children's parent id (cuts link)
+    def nullify_children
+      children.each do |c|
+        c.parent = nil
+        c.save
+      end
+    end
+
+    # delete children; this *removes all of the children fromt he data base (and ensuing)
+    def destroy_children
+      children.destroy_all
+    end
+
+    # move all children to the parent node
+    def move_children_to_parent
+      children.each do |c|
+        self.parent.children << c
+        c.parent = self.parent  # is this necessary?
+      end
+    end
+
+    # perform validation on whether this child is an acceptable child or not?
+    # the base_class must have a method 'is_valid_child?' to implement domain logic there
+    def validate_child!(ch)
+      raise InvalidChild "Attempted to add nil child to #{self}" if (ch == nil)
+      raise CircularRelation, "Circular relationship adding #{ch} to #{self}" if self.descendant_of?(ch)
+      if base_class.method_defined? :is_valid_child?
+        self.validate_child(ch)  # this should throw an error if not valid
+      end
+    end
+
+    # perform validation on whether this parent is an acceptable parent or not?
+    # the base_class should have a method 'is_valid_parent?'  to invoke domain logic
+    # calls - invalid_parent_error(ch), if it exists, if the parent is invalid (for error handling)
+    # def validate_parent(pa)
+    #   if (pa == nil) || (pa == self)
+    #     self.invalid_parent_error(pa)
+    #   else
+    #     while par != nil do
+    #       unless self.is_valid_parent(pa)
+    #       end
+    #     end
+    #   end
+    # end
+
+    # to do - find a way to add a Mongoid criteria to return all of the nodes for this object
+    # descendants
+    # descendants_and_self
+    # ancestors
+    # ancestors_and_self
+
+  end # Tree
+end # Taxonomite

data/lib/taxonomite/version.rb

@@ -0,0 +1,3 @@
+module Taxonomite
+  VERSION = "0.1.0"
+end

data/spec/controllers/taxonomite/taxonomite_controller_spec.rb

@@ -0,0 +1,31 @@
+require 'rails_helper'
+require 'spec_helper'
+require 'taxonomite/node'
+
+module Taxonomite
+
+  RSpec.describe TaxonomiteController, type: :controller do
+
+    before :all do
+      # populate the database prior to trying index/get
+      @sample = FactoryGirl.create(:taxonomite_node)
+    end
+
+    describe "GET #index" do
+      it "returns http success" do
+        get :index
+        expect(response).to have_http_status(:success)
+      end
+    end
+
+    # really just test that an invalid id (=1) fails
+    describe "GET #show" do
+      it "returns http success" do
+        get :show, :id => @sample.id
+        expect(response).to have_http_status(:success)
+      end
+    end
+
+  end
+
+end

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.