deep_dive 0.0.2

data/.semver

@@ -0,0 +1,5 @@
+---
+:major: 0
+:minor: 0
+:patch: 2
+:special: ''

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+ruby '2.0.0'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.8.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 1.8.7"
+  gem "simplecov"
+  gem 'semver'
+end

data/Gemfile.lock

@@ -0,0 +1,72 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    builder (3.2.2)
+    diff-lcs (1.1.3)
+    docile (1.1.1)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    git (1.2.6)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.20)
+    httpauth (0.2.0)
+    jeweler (1.8.8)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    multi_json (1.8.2)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (0.9.2)
+      faraday (~> 0.8)
+      httpauth (~> 0.2)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.1)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    semver (1.0.1)
+    simplecov (0.8.2)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  jeweler (~> 1.8.7)
+  rdoc (~> 3.12)
+  rspec (~> 2.8.0)
+  semver
+  simplecov

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Fred Mitchell
+
+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.rdoc

@@ -0,0 +1,28 @@
+= DeepDive Deep Contolled Cloning
+
+When you have a system of objects that have many references to each other, it becomes an
+issue to be able to clone properly that object graph. There may be control objects you may
+not want to clone, but maintain references to. And some references you may not wish to clone at all.
+
+Enter DeepDive. Allows you a means by which you can do controlled deep cloning or
+copying of your complex interconnected objects.
+
+== Usage
+Simply include DeepDive in your base class. All classes derived will be set
+for deep cloning or deep duping.
+
+== Contributing to deep_dive
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 Fred Mitchell. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+require 'semver'
+
+def s_version
+  SemVer.find.format "%M.%m.%p%s"
+end
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "deep_dive"
+  gem.homepage = "https://github.com/flajann2/deep_dive"
+  gem.license = "MIT"
+  gem.summary = %Q{DeepDive Deep Contolled Cloning}
+  gem.version = s_version
+  gem.description = %Q{
+  When you have a system of objects that have many references to each other, it becomes an
+  issue to be able to clone properly that object graph. There may be control objects you may
+  not want to clone, but maintain references to. And some references you may not wish to clone at all.
+
+  Enter DeepDive. Allows you a means by which you can do controlled deep cloning or
+  copying of your complex interconnected objects.
+  }
+  gem.email = "fred@lrcsoft.com"
+  gem.authors = ["Fred Mitchell"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = s_version
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "deep_dive #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/deep_dive.gemspec

@@ -0,0 +1,76 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "deep_dive"
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Fred Mitchell"]
+  s.date = "2013-12-30"
+  s.description = "\n  When you have a system of objects that have many references to each other, it becomes an\n  issue to be able to clone properly that object graph. There may be control objects you may\n  not want to clone, but maintain references to. And some references you may not wish to clone at all.\n\n  Enter DeepDive. Allows you a means by which you can do controlled deep cloning or\n  copying of your complex interconnected objects.\n  "
+  s.email = "fred@lrcsoft.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".idea/.name",
+    ".idea/.rakeTasks",
+    ".idea/deep_dive.iml",
+    ".idea/encodings.xml",
+    ".idea/misc.xml",
+    ".idea/modules.xml",
+    ".idea/scopes/scope_settings.xml",
+    ".idea/vcs.xml",
+    ".idea/workspace.xml",
+    ".rspec",
+    ".semver",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "deep_dive.gemspec",
+    "lib/deep_dive.rb",
+    "lib/deep_dive/deep_dive.rb",
+    "spec/lib/deep_dive/deep_dive_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "https://github.com/flajann2/deep_dive"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "2.0.14"
+  s.summary = "DeepDive Deep Contolled Cloning"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.7"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<semver>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.7"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<semver>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.7"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<semver>, [">= 0"])
+  end
+end
+

data/lib/deep_dive/deep_dive.rb

@@ -0,0 +1,125 @@
+=begin rdoc
+=DeepDive Deep Contolled Cloning
+
+When you have a system of objects that have many references to each other, it becomes an
+issue to be able to clone properly that object graph. There may be control objects you may
+not want to clone, but maintain references to. And some references you may not wish to clone at all.
+
+Enter DeepDive. Allows you a means by which you can do controlled deep cloning or
+copying of your complex interconnected objects.
+
+=Usage
+Simply include DeepDive in your base class. All classes derived will be set
+for deep cloning or deep duping.
+=end
+require 'set'
+
+module DeepDive
+  class DeepDiveException < Exception
+  end
+
+  # #ddup is a Deep Dive's replacement for #dup.
+  def ddup
+    _replicate dupit: true
+  end
+
+  # #dclone is Deep Dive's replacement for #clone.
+  def dclone
+    _replicate dupit: false
+  end
+
+  # not meant to be called externally. Use either ddup or dclone.
+  def _replicate(dupit: true, oc: {})
+    unless oc.member? self
+      copy = oc[self] = if dupit
+                          dup
+                        else
+                          clone
+                        end
+      copy.instance_variables.map do |var|
+        [var, instance_variable_get(var)]
+      end.reject do |var, ob|
+        not ob.respond_to? :_replicate
+      end.reject do |var, ob|
+        self.class.excluded? var
+      end.each do |var, value|
+        copy.instance_variable_set(var, value._replicate(oc: oc, dupit: dupit))
+      end
+    end
+    oc[self]
+  end
+
+  # For all enumerable objects, we will have to handle their situation
+  # differently.
+  module ::Enumerable
+    # add a single element to the enumerable.
+    # You may pass a single parameter, or a key, value. In any case,
+    # all will added.
+    #
+    # Here all the logic will be present to handle the "special case"
+    # enumerables. Most notedly, Hash and Array will require special
+    # treatment.
+    def _add(v: nil, dupit: nil, oc: nil)
+      unless _pairs?
+        case
+          when self.kind_of?(Set)
+          when self.kind_of?(Array)
+            self << v._replicate(oc: oc, dupit: dupit)
+          else
+            raise DeepDiveException.new("Don't know how to add new elements for class #{self.class}")
+        end
+      else
+        self[v.first] = v.last._replicate(oc: oc, dupit: dupit)
+      end
+    end
+
+    # We try to determine if this enumberable will return pairs
+    # (as in the case of a Hash) or objects (which may look like pairs
+    # but not really).
+    def _pairs?
+      self.kind_of? Hash
+    end
+
+    # Here, with this Enumerator, we want to create a new empty instance
+    # and populate it with replicas (or references) of the contained
+    # objects.
+    #
+    # here, a nasty problem is that there is no unified API for *adding*
+    # or *substituting* objects into the new collection, so we are going
+    # to abstract that issue to #_add.
+    #
+    # FIXME: We will initially not handle Enumberables that have instance variables.
+    # FIXME: This issue will be addressed at a later date.
+    def _replicate(dupit: true, oc: {})
+      unless oc.member? self
+        self.inject(oc[self] = self.class.new) do |copy, v|
+          copy._add(v: v, dupit: dupit, oc: oc)
+          copy
+        end
+      end
+      oc[self]
+    end
+  end
+
+  module CMeth
+    @@exclusion = []
+    # exclusion list of instance variables to dup/clone
+    def exclude(*list)
+      @@exclusion << list.map { |s| "@#{s}".to_sym }
+      @@exclusion.flatten!
+    end
+
+    # Internal function not meant to be called by the application.
+    def excluded?(sym)
+      @@exclusion.member? sym
+    end
+  end
+
+  def self.included(base)
+    base.extend(CMeth)
+  end
+
+  def self.inherited(sub)
+    sub.include(DeepDive)
+  end
+end

data/lib/deep_dive.rb

@@ -0,0 +1 @@
+require 'deep_dive/deep_dive'

data/spec/lib/deep_dive/deep_dive_spec.rb

@@ -0,0 +1,86 @@
+require 'deep_dive'
+
+class FooBase
+  include DeepDive
+  exclude :c
+end
+
+class Foo < FooBase
+  attr_accessor :a, :b, :c, :changeme
+end
+
+class Bar < FooBase
+  attr_accessor :a, :b, :c, :changeme
+end
+
+class FooBar < FooBase
+  attr_accessor :a, :b, :c, :changeme, :dontcopy, :arr, :hsh
+  exclude :dontcopy
+end
+
+describe DeepDive do
+  before(:each) do
+    @foo = Foo.new
+    @bar = Bar.new
+    @foobar = FooBar.new
+    @foobar.arr = [@foo, @bar, @foobar]
+    @foobar.hsh = {foo: @foo, bar: @bar, foobar: @foobar}
+
+    @foo.a = 'foo just around'
+    @bar.a = 'bar hanging around'
+    @foo.b = @bar
+    @bar.b = @foo
+    @foo.c = @bar.c = @foobar.c = @foobar
+    @foo.changeme = @bar.changeme = @foobar.changeme = "initial"
+  end
+
+
+  context 'clone' do
+    it 'simple' do
+      cfoo = @foo.dclone
+      cfoo.should_not == nil
+      cfoo.should_not == @foo
+      @foo.b.changeme = 'changed'
+      @foobar.changeme = 'also changed'
+      cfoo.c.changeme.should == @foobar.changeme
+      cfoo.b.changeme.should_not == @foo.b.changeme
+    end
+
+    it 'exclusion' do
+      @foobar.dontcopy = @bar
+      cfoobar = @foobar.dclone
+      cfoobar.dontcopy.should == @foobar.dontcopy
+
+      @foo.a = @bar
+      cfoo = @foo.dclone
+      cfoo.a.should_not == @foo.a
+    end
+  end
+
+  context 'dup' do
+    it 'simple' do
+      cfoo = @foo.ddup
+      cfoo.should_not == nil
+    end
+    it 'deep'
+  end
+
+  context 'enumerables' do
+    it 'makes copies of the arrayed objects' do
+      cfb = @foobar.dclone
+      cfb.arr.size.should > 0
+      (0 ... cfb.arr.size).each do |i|
+        cfb.arr[i].should_not be_nil
+        cfb.arr[i].should_not == @foobar.arr[i]
+      end
+    end
+
+    it 'makes copies of the hashed objects' do
+      cfb = @foobar.dclone
+      cfb.hsh.size.should > 0
+      cfb.hsh.each do |k, o|
+        cfb.hsh[k].should_not == @foobar.hsh[k]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'deep_dive'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: deep_dive
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Fred Mitchell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: semver
+  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: "\n  When you have a system of objects that have many references to each
+  other, it becomes an\n  issue to be able to clone properly that object graph. There
+  may be control objects you may\n  not want to clone, but maintain references to.
+  And some references you may not wish to clone at all.\n\n  Enter DeepDive. Allows
+  you a means by which you can do controlled deep cloning or\n  copying of your complex
+  interconnected objects.\n  "
+email: fred@lrcsoft.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .idea/.name
+- .idea/.rakeTasks
+- .idea/deep_dive.iml
+- .idea/encodings.xml
+- .idea/misc.xml
+- .idea/modules.xml
+- .idea/scopes/scope_settings.xml
+- .idea/vcs.xml
+- .idea/workspace.xml
+- .rspec
+- .semver
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- deep_dive.gemspec
+- lib/deep_dive.rb
+- lib/deep_dive/deep_dive.rb
+- spec/lib/deep_dive/deep_dive_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/flajann2/deep_dive
+licenses:
+- MIT
+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.0.14
+signing_key: 
+specification_version: 4
+summary: DeepDive Deep Contolled Cloning
+test_files: []