dm-is-awesome_set 0.10.2 → 0.11.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Jeremy Nicoll (http://gnexp.com, jnicoll@gnexp.com)
+Copyright (c) 2008,2009,2010 Jeremy Nicoll (http://gnexp.com, jnicoll@gnexp.com)
 
 Some code and documentation janked from dm-is-nested_set by Sindre Aarsaether
 (somebee.com)

data/Rakefile

@@ -6,6 +6,8 @@ begin
   gem 'jeweler', '>= 1.4'
   require 'jeweler'
 
+  FileList['tasks/**/*.rake'].each { |task| load task }
+
   Jeweler::Tasks.new do |gem|
 
     gem.name        = "dm-is-awesome_set"
@@ -15,9 +17,9 @@ begin
     gem.homepage    = "http://github.com/snusnu/dm-is-awesome_set"
     gem.authors     = ["Jeremy Nicoll", "David Haslem", "Martin Gamsjaeger (snusnu)"]
 
-    gem.add_dependency 'dm-core',       '~> 0.10'
-    gem.add_dependency 'dm-adjust',     '~> 0.10'
-    gem.add_dependency 'dm-aggregates', '~> 0.10'
+    gem.add_dependency 'dm-core',           '~> 0.10'
+    gem.add_dependency 'dm-adjust',         '~> 0.10'
+    gem.add_dependency 'dm-aggregates',     '~> 0.10'
 
     gem.add_development_dependency 'rspec', '~> 1.2.9'
 

data/VERSION

@@ -1 +1 @@
-0.10.2
+0.11.0

data/dm-is-awesome_set.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dm-is-awesome_set}
-  s.version = "0.10.2"
+  s.version = "0.11.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jeremy Nicoll", "David Haslem", "Martin Gamsjaeger (snusnu)"]
-  s.date = %q{2010-02-19}
+  s.date = %q{2010-02-17}
   s.description = %q{A library that lets any datamapper model act like a nested set}
   s.email = %q{jnicoll@gnexp.com}
   s.extra_rdoc_files = [
@@ -26,9 +26,16 @@ Gem::Specification.new do |s|
      "VERSION",
      "dm-is-awesome_set.gemspec",
      "lib/dm-is-awesome_set.rb",
-     "lib/dm-is-awesome_set/is/awesome_set.rb",
      "spec/dm-is-awesome_set_spec.rb",
-     "spec/spec_helper.rb"
+     "spec/rcov.opts",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "tasks/changelog.rake",
+     "tasks/ci.rake",
+     "tasks/metrics.rake",
+     "tasks/spec.rake",
+     "tasks/yard.rake",
+     "tasks/yardstick.rake"
   ]
   s.homepage = %q{http://github.com/snusnu/dm-is-awesome_set}
   s.rdoc_options = ["--charset=UTF-8"]

data/lib/dm-is-awesome_set.rb

@@ -1,5 +1,428 @@
-require 'pathname'
-['dm-core', 'dm-adjust', 'dm-aggregates', 'dm-validations'].each do |dm_var|
-  require dm_var
-end
-require Pathname(__FILE__).dirname.expand_path / 'dm-is-awesome_set' / 'is' / 'awesome_set.rb'
+module DataMapper
+  module Is
+    ##
+    # Thanks for looking into dm-is-awesome_set.  What makes it so awesome?  Well,
+    # the fact that it actually works.  At least I think it does.  Give it a whirl,
+    # and if you come across any bugs let me know (check the readme file for
+    # information).  Most of what you will be concerned with is the move method,
+    # though there are some other helper methods for selecting nodes.
+    # The way you use it in your model is like so:
+    #
+    # def ModelName
+    #   include DataMapper::Resource
+    #   # ... set up your properties ...
+    #  is :awesome_set, :scope => [:col1, :col2], :child_key => [:parent_id]
+    # end
+    #
+    # Note that scope is optional, and :child_key's default is [:parent_id]
+
+    module AwesomeSet
+      # Available options for is awesome_set:
+      #   :scope => array of keys for scope (default is [])
+      #   :child_key => array of keys for setting the parent-child relationship (default is [:parent_id])
+
+      def is_awesome_set(options={})
+        extend  DataMapper::Is::AwesomeSet::ClassMethods
+        include DataMapper::Is::AwesomeSet::InstanceMethods
+
+        opts = set_options(options)
+        [:child_key, :scope].each {|var| raise "#{var} must be an Array" unless opts[var].is_a?(Array)}
+
+        property :parent_id, Integer, :min => 0, :writer => :protected
+
+        property :lft, Integer, :writer => :private, :index => true
+        property :rgt, Integer, :writer => :private, :index => true
+
+        class_opts = {:model => self.name, :child_key => opts[:child_key], :order => [:lft.asc] }
+        belongs_to :parent,  class_opts
+        has n,     :children, class_opts
+
+        before :save_self do
+          move_without_saving(:root) if lft.nil? #You don't want to use new_record? here.  Trust me, you don't.
+        end
+
+      end # def is_awesome_set
+
+      module ClassMethods
+        def set_options(options) #:nodoc:
+          @ias_options = { :child_key => [:parent_id], :scope => [] }.merge(options)
+        end
+
+        def ias_options;  @ias_options || superclass.ias_options end #:nodoc:
+
+        def child_keys; ias_options[:child_key]; end
+        def scope_keys; ias_options[:scope]; end
+        def is_nested_set? #:nodoc:
+          true
+        end
+
+        # Checks to see if the hash or object contains a valid scope by checking attributes or keys
+        def valid_scope?(hash)
+          return true if hash.is_a?(self)
+          return false unless hash.is_a?(Hash)
+          scope_keys.each { |sk| return false unless hash.keys.include?(sk) }
+          true
+        end
+
+        # Raises an error if the scope is not valid
+        def check_scope(hash)
+          raise 'Invalid scope: ' + hash.inspect if !valid_scope?(hash)
+        end
+
+        # Return only the attributes that deal with the scope, will raise an error on invalid scope
+        def extract_scope(hash)
+          check_scope(hash)
+          ret = {}
+          send_to_obj = hash.is_a?(self)
+          scope_keys.each { |sk| ret[sk] = send_to_obj ? hash.attribute_get(sk) : hash[sk] }
+          ret
+        end
+
+        def adjust_gap!(scoped_set, at, adjustment) #:nodoc:
+          scoped_set.all(:rgt.gt => at).adjust!({:rgt => adjustment},true)
+          scoped_set.all(:lft.gt => at).adjust!({:lft => adjustment},true)
+        end
+
+        # Return a hash that gets the roots
+        def root_hash
+          ret = {}
+          child_keys.each { |ck| ret[ck] = nil }
+          ret
+        end
+
+
+        # Get the root with no args if there is no scope
+        # Pass the scope or an object with scope to get the first root
+        def root(scope = {})
+          scope = extract_scope(scope)
+          get_class.first(scope.merge(root_hash.merge(:order => [:lft.asc])))
+        end
+
+        # Same as @root, but gets all roots
+        def roots(scope = {})
+          scope = extract_scope(scope)
+          get_class.all(scope.merge(root_hash.merge(:order => [:lft.asc])))
+        end
+
+        # Gets the full set with scope behavior like @root
+        def full_set(scope = {})
+          scope = extract_scope(scope)
+          get_class.all(scope.merge(:order => [:lft.asc]))
+        end
+
+        # Retrieves all nodes that do not have children.
+        # This needs to be refactored for more of a DM style, if possible.
+        def leaves(scope = {})
+          scope = extract_scope(scope)
+          get_class.all(scope.merge(:order => [:lft.asc], :conditions => ["`rgt` - `lft` = 1"]))
+        end
+
+        # Since DataMapper looks for all records in a table when using discriminators
+        # when using the parent model , we'll look for the earliest ancestor class
+        # that is a nested set.
+        def get_class #:nodoc:
+          klass = self
+          klass = klass.superclass while klass.superclass.respond_to?(:is_nested_set?) && klass.superclass.is_nested_set?
+          klass
+        end
+      end # mod ClassMethods
+
+      module InstanceMethods
+        ##
+        # move self / node to a position in the set. position can _only_ be changed through this
+        #
+        # @example [Usage]
+        #   * node.move :higher           # moves node higher unless it is at the top of parent
+        #   * node.move :lower            # moves node lower unless it is at the bottom of parent
+        #   * node.move :below => other   # moves this node below other resource in the set
+        #   * node.move :into => other    # same as setting a parent-relationship
+        #
+        # @param vector <Symbol, Hash> A symbol, or a key-value pair that describes the requested movement
+        #
+        # @option :higher<Symbol> move node higher
+        # @option :highest<Symbol> move node to the top of the list (within its parent)
+        # @option :lower<Symbol> move node lower
+        # @option :lowest<Symbol> move node to the bottom of the list (within its parent)
+        # @option :indent<Symbol> move node into sibling above
+        # @option :outdent<Symbol> move node out below its current parent
+        # @option :root<Symbol|Hash|Resource> move node to root.  If passed an object / hash, it uses the scope of that.  Otherwise, it uses currently set scope.
+        # @option :into<Resource> move node into another node
+        # @option :above<Resource> move node above other node
+        # @option :below<Resource> move node below other node
+        # @option :to<Integer> move node to a specific location in the nested set
+        # @see move_without_saving
+
+        def move(vector)
+          transaction do
+            move_without_saving(vector)
+            save!
+          end
+          reload
+        end
+
+        def level
+          ancestors.length
+        end
+
+        # Gets the root of this node
+        def root
+          get_class.first(root_hash.merge(:lft.lt => lft, :rgt.gt => rgt))
+        end
+
+        # Gets all the roots of this node's tree
+        def roots
+          get_class.all(root_hash.merge(:order => [:lft.asc]))
+        end
+
+        # Gets all ancestors of this node
+        def ancestors
+          get_class.all(scope_hash.merge(:lft.lt => lft, :rgt.gt => rgt, :order => [:lft.asc]))
+        end
+
+        # Same as ancestors, but also including this node
+        def self_and_ancestors
+          get_class.all(scope_hash.merge(:lft.lte => lft, :rgt.gte => rgt, :order => [:lft.asc]))
+        end
+
+        # Gets all nodes that share the same parent node, except for this node
+        def siblings
+          get_class.all(scope_and_parent_hash.merge(:order => [:lft.asc], :lft.not => lft))
+        end
+
+        # Same as siblings, but returns this node as well
+        def self_and_siblings
+          get_class.all(scope_and_parent_hash.merge(:order => [:lft.asc]))
+        end
+
+        # Returns next node with same parent, or nil
+        def next_sibling
+          get_class.first(scope_and_parent_hash.merge(:lft.gt => rgt, :order => [:lft.asc]))
+        end
+
+        # Returns previous node with same parent, or nil
+        def previous_sibling
+          get_class.first(scope_and_parent_hash.merge(:rgt.lt => lft, :order => [:rgt.desc]))
+        end
+
+        # Returns the full set within this scope
+        def full_set
+          get_class.all(scope_hash)
+        end
+
+        # Gets all descendents of this node
+        def descendents
+          get_class.all(scope_hash.merge(:rgt.lt => rgt, :lft.gt => lft, :order => [:lft.asc]))
+        end
+
+
+        # Same as descendents, but returns self as well
+        def self_and_descendents
+          get_class.all(scope_hash.merge(:rgt.lte => rgt, :lft.gte => lft, :order => [:lft.asc]))
+        end
+
+
+        # Fixed spelling for when English majors are peering over your shoulder
+        def descendants; descendents; end
+        def self_and_descendants;  self_and_descendents; end
+
+        # Retrieves the nodes without any children.
+        def leaves
+          get_class.leaves(self)
+        end
+
+        def attributes_set(hash) #:nodoc:
+          hash = hash || {}
+          hash.each { |k,v| attribute_set(k,v) }
+        end
+
+        # Destroys the current node and all children nodes, running their before and after hooks
+        # Returns the destroyed objects
+        def destroy
+          sads = self_and_descendants
+          hooks = get_class.const_get('INSTANCE_HOOKS')
+          before_methods = hooks[:destroy][:before].map { |hash| hash[:name] }
+          after_methods =  hooks[:destroy][:after].map  { |hash| hash[:name] }
+          # Trigger all the before :destroy methods
+          sads.each { |sad| before_methods.each { |bf| sad.send(bf) } }
+          # dup is called here because destroy! likes to clear out the array, understandably.
+          transaction do
+            sads.dup.destroy!
+            adjust_gap!(full_set, lft, -(rgt - lft + 1))
+          end
+          # Now go through after all the after :destroy methods.
+          sads.each { |sad| after_methods.each { |bf| sad.send(bf) } }
+        end
+
+        # Same as @destroy, but does not run the hooks
+        def destroy!
+          sad = self_and_descendants
+          transaction do
+            sad.dup.destroy!
+            adjust_gap!(full_set, lft, -(rgt - lft + 1))
+          end
+          sad
+        end
+
+      protected
+        def skip_adjust=(var) #:nodoc:
+          @skip_adjust = true
+        end
+
+        def adjust_gap!(*args) #:nodoc:
+          get_class.adjust_gap!(*args)
+        end
+
+        def get_finder_hash(*args)
+          ret = {}
+          args.each { |arg| get_class.ias_options[arg].each { |s| ret[s] = send(s) } }
+          ret
+        end
+
+        def root_hash
+          ret = {}
+          get_class.child_keys.each { |ck| ret[ck] = nil }
+          scope_hash.merge(ret)
+        end
+
+        def scope_and_parent_hash
+          get_finder_hash(:child_key, :scope)
+        end
+
+        def extract_scope(hash)
+          get_class.extract_scope(hash)
+        end
+
+        def scope_hash
+          get_finder_hash(:scope)
+        end
+
+        def parent_hash
+          get_finder_hash(:child_key)
+        end
+
+        def same_scope?(obj)
+          case obj
+          when get_class  :  scope_hash == obj.send(:scope_hash)
+          when Hash   :   scope_hash == obj
+          when nil    :   true
+          end
+        end
+
+        def valid_scope?(hash)
+          get_class.valid_scope?(hash)
+        end
+
+        def move_without_saving(vector)
+          # Do some checking of the variable...
+          if vector.respond_to?(:'[]') && vector.respond_to?(:size) && vector.size == 1
+            action = vector.keys[0]
+            obj = vector[action]
+          elsif vector.is_a?(Symbol)
+            obj = nil
+            action = vector
+          else
+            raise 'You must pass either a symbol or a hash with one property to the method "move".'
+          end
+
+
+          # Convenience methods
+          ret_value = case action
+          when :higher :  previous_sibling ? move_without_saving(:above => previous_sibling) : false
+          when :highest : move_without_saving(:to => parent ? (parent.lft + 1) : 1)
+          when :lower : next_sibling ? move_without_saving(:below => next_sibling) : false
+          when :lowest : parent ? move_without_saving(:to => parent.rgt - 1) : move_without_saving(:root)
+          when :indent : previous_sibling ? move_without_saving(:into => previous_sibling) : false
+          when :outdent : parent ? move_without_saving(:below => parent) : false
+          else :no_action
+          end
+          return ret_value unless ret_value == :no_action
+
+          this_gap = lft.to_i > 0 && rgt.to_i > 0 ? rgt - lft : 1
+          old_parent = parent
+          new_scope = nil
+          max = nil
+
+          # Here's where the real heavy lifting happens. Any action can be taken
+          # care of by :root, :above, :below, or :to
+          pos, adjust_at, p_obj = case action
+          when :root
+            new_scope = obj ? extract_scope(obj) : scope_hash
+            max = (get_class.max(:rgt, new_scope) || 0) + 1
+          when :into    :  [obj.rgt, obj.rgt - 1, obj]
+          when :above   :  [obj.lft, obj.lft - 1, obj.parent]
+          when :below   :  [obj.rgt + 1, obj.rgt, obj.parent]
+          when :to
+            pos = obj.to_i
+            p_obj = get_class.first(scope_hash.merge(:lft.lt => pos, :rgt.gt => pos, :order => [:lft.desc]))
+            [pos, pos - 1, p_obj]
+          else raise 'Invalid action sent to the method "move": ' + action.to_s
+          end
+
+          old_scope = nil
+          new_scope ||= extract_scope(p_obj) if p_obj
+
+          max ||= (get_class.max(:rgt, new_scope || scope_hash) || 0) + 1
+          if pos == 0 || pos > max
+            raise "You cannot move a node outside of the bounds of the tree.  You passed: #{pos}. Acceptable numbers are 1 through #{max}"
+          end
+
+          raise 'You are trying to move a node into one that has not been saved yet.' if p_obj && p_obj.lft.nil?
+
+          if lft
+            adjustment = pos < lft ? this_gap + 1 : 0
+            raise 'Illegal move: you are trying to move a node within itself' if pos.between?(lft+adjustment,rgt+adjustment) && same_scope?(new_scope)
+          end
+
+          # make a new hole and assign parent
+          #
+          # Note: with identity map on an already saved object, making a hole
+          # will alter lft & rgt values immediately, so we need to keep copies
+          old_lft, old_rgt = lft, rgt if lft && rgt
+          adjust_gap!(get_class.full_set(new_scope || scope_hash) , adjust_at, this_gap + 1) if adjust_at
+
+          # Do we need to move the node (already present in the tree), or just save the attributes?
+          if lft && (pos != old_lft || !same_scope?(new_scope))
+            # Move elements
+            if same_scope?(new_scope)
+              move_by = pos - (old_lft + adjustment)
+              full_set.all(:lft.gte => old_lft + adjustment, :rgt.lte => old_rgt + adjustment).adjust!({:lft => move_by, :rgt => move_by}, true)
+            else # Things have to be done a little differently if moving scope
+              move_by = pos - old_lft
+              old_scope = extract_scope(self)
+              sads = self_and_descendants
+              sads.adjust!({:lft => move_by, :rgt => move_by}, true)
+              # Update the attributes to match how they are in the database now.
+              # Be sure to do this between adjust! and setting the new scope
+              attribute_set(:rgt, old_rgt + move_by)
+              attribute_set(:lft, old_lft + move_by)
+
+              sads.each { |d| d.update!(new_scope)}
+            end
+
+            # Close hole
+            if old_scope
+              adjust_gap!(get_class.full_set(old_scope), old_lft, -(this_gap + 1))
+            else
+              adjustment += 1 if parent == old_parent
+              adjust_gap!(full_set, old_lft + adjustment, -(this_gap + 1))
+            end
+          else # just save the attributes
+            attribute_set(:lft, pos)
+            attribute_set(:rgt, lft + this_gap)
+            attributes_set(p_obj.send(:scope_hash)) if p_obj
+          end
+          # We set parent here because we don't want to throw errors with dirty
+          # tracking during all of the adjust! and update!(scope) calls
+          self.parent = p_obj
+
+        end
+
+        def get_class #:no_doc:
+          self.class.get_class
+        end
+      end # mod InstanceMethods
+
+      Model.send(:include, self)
+    end # mod AwesomeSet
+  end # mod Is
+end # mod DM

data/spec/dm-is-awesome_set_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 
 
 scope = {:scope => 1, :scope_2 => 2}

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--loadby random
+--format specdoc
+--backtrace

data/spec/spec_helper.rb

@@ -1,12 +1,15 @@
 require 'rubygems'
-$:.push File.join(File.dirname(__FILE__), '..', 'lib')
-require 'dm-is-awesome_set'
 
-# Needed for the discriminator
-gem 'dm-types', '>=0.9.7'
+require 'dm-core'
+require 'dm-adjust'
+require 'dm-aggregates'
 require 'dm-types'
 require 'dm-validations'
 
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'dm-is-awesome_set'
+
+
 ENV["SQLITE3_SPEC_URI"]  ||= 'sqlite3::memory:'
 ENV["MYSQL_SPEC_URI"]    ||= 'mysql://localhost/dm-is_awesome_set_test'
 ENV["POSTGRES_SPEC_URI"] ||= 'postgres://postgres@localhost/dm-is_awesome_set_test'

data/tasks/changelog.rake

@@ -0,0 +1,20 @@
+require 'time'
+
+desc 'update changelog'
+task :changelog do
+  File.open('CHANGELOG', 'w+') do |changelog|
+    `git log -z --abbrev-commit`.split("\0").each do |commit|
+      next if commit =~ /^Merge: \d*/
+      ref, author, time, _, title, _, message = commit.split("\n", 7)
+      ref = ref[/commit ([0-9a-f]+)/, 1]
+      author = author[/Author: (.*)/, 1].strip
+      time = Time.parse(time[/Date: (.*)/, 1]).utc
+      title.strip!
+
+      changelog.puts "[#{ref} | #{time}] #{author}"
+      changelog.puts '', " * #{title}"
+      changelog.puts '', message.rstrip if message
+      changelog.puts
+    end
+  end
+end

data/tasks/ci.rake

@@ -0,0 +1 @@
+task :ci => [ :verify_measurements, 'metrics:all' ]

data/tasks/metrics.rake

@@ -0,0 +1,36 @@
+begin
+  require 'metric_fu'
+rescue LoadError
+  namespace :metrics do
+    task :all do
+      abort 'metric_fu is not available. In order to run metrics:all, you must: gem install metric_fu'
+    end
+  end
+end
+
+begin
+  require 'reek/adapters/rake_task'
+
+  Reek::RakeTask.new do |t|
+    t.fail_on_error = true
+    t.verbose       = false
+    t.source_files  = 'lib/**/*.rb'
+  end
+rescue LoadError
+  task :reek do
+    abort 'Reek is not available. In order to run reek, you must: gem install reek'
+  end
+end
+
+begin
+  require 'roodi'
+  require 'roodi_task'
+
+  RoodiTask.new do |t|
+    t.verbose = false
+  end
+rescue LoadError
+  task :roodi do
+    abort 'Roodi is not available. In order to run roodi, you must: gem install roodi'
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,25 @@
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+spec_defaults = lambda do |spec|
+  spec.pattern    = 'spec/**/*_spec.rb'
+  spec.libs      << 'lib' << 'spec'
+  spec.spec_opts << '--options' << 'spec/spec.opts'
+end
+
+Spec::Rake::SpecTask.new(:spec, &spec_defaults)
+
+Spec::Rake::SpecTask.new(:rcov) do |rcov|
+  spec_defaults.call(rcov)
+  rcov.rcov      = true
+  rcov.rcov_opts = File.read('spec/rcov.opts').split(/\s+/)
+end
+
+RCov::VerifyTask.new(:verify_rcov => :rcov) do |rcov|
+  rcov.threshold = 100
+end
+
+task :spec => :check_dependencies
+task :rcov => :check_dependencies
+
+task :default => :spec

data/tasks/yard.rake

@@ -0,0 +1,9 @@
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end

data/tasks/yardstick.rake

@@ -0,0 +1,19 @@
+begin
+  require 'pathname'
+  require 'yardstick/rake/measurement'
+  require 'yardstick/rake/verify'
+
+  # yardstick_measure task
+  Yardstick::Rake::Measurement.new
+
+  # verify_measurements task
+  Yardstick::Rake::Verify.new do |verify|
+    verify.threshold = 100
+  end
+rescue LoadError
+  %w[ yardstick_measure verify_measurements ].each do |name|
+    task name.to_s do
+      abort "Yardstick is not available. In order to run #{name}, you must: gem install yardstick"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-is-awesome_set
 version: !ruby/object:Gem::Version 
-  version: 0.10.2
+  version: 0.11.0
 platform: ruby
 authors: 
 - Jeremy Nicoll
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-19 00:00:00 -05:00
+date: 2010-02-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,9 +73,16 @@ files:
 - VERSION
 - dm-is-awesome_set.gemspec
 - lib/dm-is-awesome_set.rb
-- lib/dm-is-awesome_set/is/awesome_set.rb
 - spec/dm-is-awesome_set_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
 - spec/spec_helper.rb
+- tasks/changelog.rake
+- tasks/ci.rake
+- tasks/metrics.rake
+- tasks/spec.rake
+- tasks/yard.rake
+- tasks/yardstick.rake
 has_rdoc: true
 homepage: http://github.com/snusnu/dm-is-awesome_set
 licenses: []

data/lib/dm-is-awesome_set/is/awesome_set.rb

@@ -1,428 +0,0 @@
-module DataMapper
-  module Is
-    ##
-    # Thanks for looking into dm-is-awesome_set.  What makes it so awesome?  Well,
-    # the fact that it actually works.  At least I think it does.  Give it a whirl,
-    # and if you come across any bugs let me know (check the readme file for
-    # information).  Most of what you will be concerned with is the move method,
-    # though there are some other helper methods for selecting nodes.
-    # The way you use it in your model is like so:
-    #
-    # def ModelName
-    #   include DataMapper::Resource
-    #   # ... set up your properties ...
-    #  is :awesome_set, :scope => [:col1, :col2], :child_key => [:parent_id]
-    # end
-    #
-    # Note that scope is optional, and :child_key's default is [:parent_id]
-
-    module AwesomeSet
-      # Available options for is awesome_set:
-      #   :scope => array of keys for scope (default is [])
-      #   :child_key => array of keys for setting the parent-child relationship (default is [:parent_id])
-
-      def is_awesome_set(options={})
-        extend  DataMapper::Is::AwesomeSet::ClassMethods
-        include DataMapper::Is::AwesomeSet::InstanceMethods
-
-        opts = set_options(options)
-        [:child_key, :scope].each {|var| raise "#{var} must be an Array" unless opts[var].is_a?(Array)}
-        
-        property :parent_id, Integer, :min => 0, :writer => :protected
-
-        property :lft, Integer, :writer => :private, :index => true
-        property :rgt, Integer, :writer => :private, :index => true
-
-        class_opts = {:model => self.name, :child_key => opts[:child_key], :order => [:lft.asc] }
-        belongs_to :parent,  class_opts
-        has n,     :children, class_opts
-
-        before :save_self do
-          move_without_saving(:root) if lft.nil? #You don't want to use new_record? here.  Trust me, you don't.
-        end
-
-      end # def is_awesome_set
-
-      module ClassMethods
-        def set_options(options) #:nodoc:
-          @ias_options = { :child_key => [:parent_id], :scope => [] }.merge(options)
-        end
-
-        def ias_options;  @ias_options || superclass.ias_options end #:nodoc:
-
-        def child_keys; ias_options[:child_key]; end
-        def scope_keys; ias_options[:scope]; end
-        def is_nested_set? #:nodoc:
-          true
-        end
-        
-        # Checks to see if the hash or object contains a valid scope by checking attributes or keys
-        def valid_scope?(hash)
-          return true if hash.is_a?(self)
-          return false unless hash.is_a?(Hash)
-          scope_keys.each { |sk| return false unless hash.keys.include?(sk) }
-          true
-        end
-
-        # Raises an error if the scope is not valid
-        def check_scope(hash)
-          raise 'Invalid scope: ' + hash.inspect if !valid_scope?(hash)
-        end
-
-        # Return only the attributes that deal with the scope, will raise an error on invalid scope
-        def extract_scope(hash)
-          check_scope(hash)
-          ret = {}
-          send_to_obj = hash.is_a?(self)
-          scope_keys.each { |sk| ret[sk] = send_to_obj ? hash.attribute_get(sk) : hash[sk] }
-          ret
-        end
-
-        def adjust_gap!(scoped_set, at, adjustment) #:nodoc:
-          scoped_set.all(:rgt.gt => at).adjust!({:rgt => adjustment},true)
-          scoped_set.all(:lft.gt => at).adjust!({:lft => adjustment},true)
-        end
-
-        # Return a hash that gets the roots
-        def root_hash
-          ret = {}
-          child_keys.each { |ck| ret[ck] = nil }
-          ret
-        end
-
-
-        # Get the root with no args if there is no scope
-        # Pass the scope or an object with scope to get the first root
-        def root(scope = {})
-          scope = extract_scope(scope)
-          get_class.first(scope.merge(root_hash.merge(:order => [:lft.asc])))
-        end
-
-        # Same as @root, but gets all roots
-        def roots(scope = {})
-          scope = extract_scope(scope)
-          get_class.all(scope.merge(root_hash.merge(:order => [:lft.asc])))
-        end
-
-        # Gets the full set with scope behavior like @root
-        def full_set(scope = {})
-          scope = extract_scope(scope)
-          get_class.all(scope.merge(:order => [:lft.asc]))
-        end
-
-        # Retrieves all nodes that do not have children.
-        # This needs to be refactored for more of a DM style, if possible.
-        def leaves(scope = {})
-          scope = extract_scope(scope)
-          get_class.all(scope.merge(:order => [:lft.asc], :conditions => ["`rgt` - `lft` = 1"]))
-        end
-        
-        # Since DataMapper looks for all records in a table when using discriminators
-        # when using the parent model , we'll look for the earliest ancestor class
-        # that is a nested set.
-        def get_class #:nodoc:
-          klass = self
-          klass = klass.superclass while klass.superclass.respond_to?(:is_nested_set?) && klass.superclass.is_nested_set?
-          klass
-        end
-      end # mod ClassMethods
-
-      module InstanceMethods
-        ##
-        # move self / node to a position in the set. position can _only_ be changed through this
-        #
-        # @example [Usage]
-        #   * node.move :higher           # moves node higher unless it is at the top of parent
-        #   * node.move :lower            # moves node lower unless it is at the bottom of parent
-        #   * node.move :below => other   # moves this node below other resource in the set
-        #   * node.move :into => other    # same as setting a parent-relationship
-        #
-        # @param vector <Symbol, Hash> A symbol, or a key-value pair that describes the requested movement
-        #
-        # @option :higher<Symbol> move node higher
-        # @option :highest<Symbol> move node to the top of the list (within its parent)
-        # @option :lower<Symbol> move node lower
-        # @option :lowest<Symbol> move node to the bottom of the list (within its parent)
-        # @option :indent<Symbol> move node into sibling above
-        # @option :outdent<Symbol> move node out below its current parent
-        # @option :root<Symbol|Hash|Resource> move node to root.  If passed an object / hash, it uses the scope of that.  Otherwise, it uses currently set scope.
-        # @option :into<Resource> move node into another node
-        # @option :above<Resource> move node above other node
-        # @option :below<Resource> move node below other node
-        # @option :to<Integer> move node to a specific location in the nested set
-        # @see move_without_saving
-
-        def move(vector)
-          transaction do
-            move_without_saving(vector)
-            save!
-          end
-          reload
-        end
-
-        def level
-          ancestors.length
-        end
-
-        # Gets the root of this node
-        def root
-          get_class.first(root_hash.merge(:lft.lt => lft, :rgt.gt => rgt))
-        end
-
-        # Gets all the roots of this node's tree
-        def roots
-          get_class.all(root_hash.merge(:order => [:lft.asc]))
-        end
-
-        # Gets all ancestors of this node
-        def ancestors
-          get_class.all(scope_hash.merge(:lft.lt => lft, :rgt.gt => rgt, :order => [:lft.asc]))
-        end
-
-        # Same as ancestors, but also including this node
-        def self_and_ancestors
-          get_class.all(scope_hash.merge(:lft.lte => lft, :rgt.gte => rgt, :order => [:lft.asc]))
-        end
-
-        # Gets all nodes that share the same parent node, except for this node
-        def siblings
-          get_class.all(scope_and_parent_hash.merge(:order => [:lft.asc], :lft.not => lft))
-        end
-
-        # Same as siblings, but returns this node as well
-        def self_and_siblings
-          get_class.all(scope_and_parent_hash.merge(:order => [:lft.asc]))
-        end
-
-        # Returns next node with same parent, or nil
-        def next_sibling
-          get_class.first(scope_and_parent_hash.merge(:lft.gt => rgt, :order => [:lft.asc]))
-        end
-
-        # Returns previous node with same parent, or nil
-        def previous_sibling
-          get_class.first(scope_and_parent_hash.merge(:rgt.lt => lft, :order => [:rgt.desc]))
-        end
-
-        # Returns the full set within this scope
-        def full_set
-          get_class.all(scope_hash)
-        end
-
-        # Gets all descendents of this node
-        def descendents
-          get_class.all(scope_hash.merge(:rgt.lt => rgt, :lft.gt => lft, :order => [:lft.asc]))
-        end
-        
-
-        # Same as descendents, but returns self as well
-        def self_and_descendents
-          get_class.all(scope_hash.merge(:rgt.lte => rgt, :lft.gte => lft, :order => [:lft.asc]))
-        end
-        
-        
-        # Fixed spelling for when English majors are peering over your shoulder 
-        def descendants; descendents; end
-        def self_and_descendants;  self_and_descendents; end
-        
-        # Retrieves the nodes without any children.
-        def leaves
-          get_class.leaves(self)
-        end
-
-        def attributes_set(hash) #:nodoc:
-          hash = hash || {}
-          hash.each { |k,v| attribute_set(k,v) }
-        end
-
-        # Destroys the current node and all children nodes, running their before and after hooks
-        # Returns the destroyed objects
-        def destroy
-          sads = self_and_descendants
-          hooks = get_class.const_get('INSTANCE_HOOKS')
-          before_methods = hooks[:destroy][:before].map { |hash| hash[:name] }
-          after_methods =  hooks[:destroy][:after].map  { |hash| hash[:name] }
-          # Trigger all the before :destroy methods
-          sads.each { |sad| before_methods.each { |bf| sad.send(bf) } }
-          # dup is called here because destroy! likes to clear out the array, understandably.
-          transaction do
-            sads.dup.destroy!
-            adjust_gap!(full_set, lft, -(rgt - lft + 1))
-          end
-          # Now go through after all the after :destroy methods.
-          sads.each { |sad| after_methods.each { |bf| sad.send(bf) } }
-        end
-
-        # Same as @destroy, but does not run the hooks
-        def destroy!
-          sad = self_and_descendants
-          transaction do
-            sad.dup.destroy!
-            adjust_gap!(full_set, lft, -(rgt - lft + 1))
-          end
-          sad
-        end
-
-      protected
-        def skip_adjust=(var) #:nodoc:
-          @skip_adjust = true
-        end
-
-        def adjust_gap!(*args) #:nodoc:
-          get_class.adjust_gap!(*args)
-        end
-
-        def get_finder_hash(*args)
-          ret = {}
-          args.each { |arg| get_class.ias_options[arg].each { |s| ret[s] = send(s) } }
-          ret
-        end
-
-        def root_hash
-          ret = {}
-          get_class.child_keys.each { |ck| ret[ck] = nil }
-          scope_hash.merge(ret)
-        end
-
-        def scope_and_parent_hash
-          get_finder_hash(:child_key, :scope)
-        end
-
-        def extract_scope(hash)
-          get_class.extract_scope(hash)
-        end
-
-        def scope_hash
-          get_finder_hash(:scope)
-        end
-
-        def parent_hash
-          get_finder_hash(:child_key)
-        end
-
-        def same_scope?(obj)
-          case obj
-          when get_class  then  scope_hash == obj.send(:scope_hash)
-          when Hash   then   scope_hash == obj
-          when nil    then   true
-          end
-        end
-
-        def valid_scope?(hash)
-          get_class.valid_scope?(hash)
-        end
-
-        def move_without_saving(vector)
-          # Do some checking of the variable...
-          if vector.respond_to?(:'[]') && vector.respond_to?(:size) && vector.size == 1
-            action = vector.keys[0]
-            obj = vector[action]
-          elsif vector.is_a?(Symbol)
-            obj = nil
-            action = vector
-          else
-            raise 'You must pass either a symbol or a hash with one property to the method "move".'
-          end
-
-
-          # Convenience methods
-          ret_value = case action
-          when :higher then  previous_sibling ? move_without_saving(:above => previous_sibling) : false
-          when :highest then move_without_saving(:to => parent ? (parent.lft + 1) : 1)
-          when :lower then next_sibling ? move_without_saving(:below => next_sibling) : false
-          when :lowest then parent ? move_without_saving(:to => parent.rgt - 1) : move_without_saving(:root)
-          when :indent then previous_sibling ? move_without_saving(:into => previous_sibling) : false
-          when :outdent then parent ? move_without_saving(:below => parent) : false
-          else :no_action
-          end
-          return ret_value unless ret_value == :no_action
-
-          this_gap = lft.to_i > 0 && rgt.to_i > 0 ? rgt - lft : 1
-          old_parent = parent
-          new_scope = nil
-          max = nil
-
-          # Here's where the real heavy lifting happens. Any action can be taken
-          # care of by :root, :above, :below, or :to
-          pos, adjust_at, p_obj = case action
-          when :root
-            new_scope = obj ? extract_scope(obj) : scope_hash
-            max = (get_class.max(:rgt, new_scope) || 0) + 1
-          when :into    then  [obj.rgt, obj.rgt - 1, obj]
-          when :above   then  [obj.lft, obj.lft - 1, obj.parent]
-          when :below   then  [obj.rgt + 1, obj.rgt, obj.parent]
-          when :to
-            pos = obj.to_i
-            p_obj = get_class.first(scope_hash.merge(:lft.lt => pos, :rgt.gt => pos, :order => [:lft.desc]))
-            [pos, pos - 1, p_obj]
-          else raise 'Invalid action sent to the method "move": ' + action.to_s
-          end
-
-          old_scope = nil
-          new_scope ||= extract_scope(p_obj) if p_obj
-
-          max ||= (get_class.max(:rgt, new_scope || scope_hash) || 0) + 1
-          if pos == 0 || pos > max
-            raise "You cannot move a node outside of the bounds of the tree.  You passed: #{pos}. Acceptable numbers are 1 through #{max}"
-          end
-
-          raise 'You are trying to move a node into one that has not been saved yet.' if p_obj && p_obj.lft.nil?
-
-          if lft
-            adjustment = pos < lft ? this_gap + 1 : 0
-            raise 'Illegal move: you are trying to move a node within itself' if pos.between?(lft+adjustment,rgt+adjustment) && same_scope?(new_scope)
-          end
-
-          # make a new hole and assign parent
-          # 
-          # Note: with identity map on an already saved object, making a hole
-          # will alter lft & rgt values immediately, so we need to keep copies
-          old_lft, old_rgt = lft, rgt if lft && rgt
-          adjust_gap!(get_class.full_set(new_scope || scope_hash) , adjust_at, this_gap + 1) if adjust_at
-          
-          # Do we need to move the node (already present in the tree), or just save the attributes?
-          if lft && (pos != old_lft || !same_scope?(new_scope))
-            # Move elements
-            if same_scope?(new_scope)
-              move_by = pos - (old_lft + adjustment)
-              full_set.all(:lft.gte => old_lft + adjustment, :rgt.lte => old_rgt + adjustment).adjust!({:lft => move_by, :rgt => move_by}, true)
-            else # Things have to be done a little differently if moving scope
-              move_by = pos - old_lft
-              old_scope = extract_scope(self)
-              sads = self_and_descendants
-              sads.adjust!({:lft => move_by, :rgt => move_by}, true)
-              # Update the attributes to match how they are in the database now.
-              # Be sure to do this between adjust! and setting the new scope
-              attribute_set(:rgt, old_rgt + move_by)
-              attribute_set(:lft, old_lft + move_by)
-              
-              sads.each { |d| d.update!(new_scope)} 
-            end
-
-            # Close hole
-            if old_scope
-              adjust_gap!(get_class.full_set(old_scope), old_lft, -(this_gap + 1))
-            else
-              adjustment += 1 if parent == old_parent
-              adjust_gap!(full_set, old_lft + adjustment, -(this_gap + 1))
-            end
-          else # just save the attributes
-            attribute_set(:lft, pos)
-            attribute_set(:rgt, lft + this_gap)
-            attributes_set(p_obj.send(:scope_hash)) if p_obj
-          end
-          # We set parent here because we don't want to throw errors with dirty
-          # tracking during all of the adjust! and update!(scope) calls
-          self.parent = p_obj
-          
-        end
-        
-        def get_class #:no_doc:
-          self.class.get_class
-        end
-      end # mod InstanceMethods
-
-      Model.send(:include, self)
-    end # mod AwesomeSet
-  end # mod Is
-end # mod DM