dm-is-temporal 0.0.1

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Joe Kutner
+
+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,73 @@
+dm-is-temporal
+==================================
+
+DataMapper plugin implementing temporal patterns on DataMapper models.
+
+These patterns are based on research by Martin Fowler, Richard Snodgrass and others.  For more information follow these links:
+
++  [Temporal Patterns](http://martinfowler.com/eaaDev/timeNarrative.html)
+
++  [Developing Time-Oriented Database Applications in SQL](http://www.cs.arizona.edu/people/rts/publications.html)
+
+Examples
+---------
+
+    require 'rubygems'
+    require 'dm-core'
+    require 'dm-migrations'
+    require 'dm-is-temporal'
+    
+    DataMapper.setup(:default, "sqlite3::memory:")
+        
+    class MyModel
+      include DataMapper::Resource
+    
+      property :id, Serial
+      property :name, String
+    
+      is_temporal do
+        property :foo, Integer
+        property :bar, String
+      end
+    end
+        
+    DataMapper.auto_migrate!
+    
+    m = MyModel.create(:name => 'start', :foo => 1)
+        
+    m.foo
+    #= 1
+    m.name  
+    #=> 'start'
+    
+    m.foo = 2
+    
+    m.name = 'hello'
+    m.name  
+    #=> 'hello'
+    
+    m.foo
+    #= 2
+    
+    m.foo = 42
+        
+    old = DateTime.parse('-4712-01-01T00:00:00+00:00')
+    m.at(old).foo
+    #=> nil
+    m.foo
+    #=> 42
+    
+    m.update(:foo => 100, :name => 'goodbye')
+    
+    m.foo
+    #=> 100
+    m.name
+    #=> 'goodbye'
+    
+
+Copyright
+----------
+
+Copyright © 2011 Joe Kutner. Released under the MIT License.
+
+See LICENSE for details.

data/Rakefile

@@ -0,0 +1,24 @@
+begin
+  gem 'jeweler', '~> 1.5.2'
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name        = 'dm-is-temporal'
+    gem.version     = '0.0.1'
+    gem.summary     = 'DataMapper plugin implementing temporal patterns'
+    gem.description = gem.summary
+    gem.email       = 'jpkutner [a] gmail [d] com'
+    gem.homepage    = 'http://github.com/jkutner/%s' % gem.name
+    gem.authors     = [ 'Joe Kutner' ]
+    gem.files =  FileList["[A-Z]*", "{lib,spec}/**/*"]
+    
+    #gem.has_rdoc    = 'yard'
+    #gem.rubyforge_project = 'datamapper'
+  end
+
+  Jeweler::GemcutterTasks.new
+
+  FileList['tasks/**/*.rake'].each { |task| import task }
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/dm-is-temporal.rb

@@ -0,0 +1,9 @@
+require 'dm-core'
+require 'dm-is-temporal/is/temporal'
+
+# Include the plugin in Resource
+module DataMapper
+  module Model
+    include DataMapper::Is::Temporal
+  end
+end

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

@@ -0,0 +1,170 @@
+module DataMapper
+  module Is
+    module Temporal
+
+      class PropertyHelper
+
+        def initialize(base)
+          @__properties__ = []
+          @__base__ = base
+        end
+
+        def property(*args)
+          @__properties__ << args
+        end
+
+        def has(*args)
+          raise 'Temporal associations are not supported yet!'
+        end
+
+        def belongs_to(*args)
+          raise 'Temporal associations are not supported yet!'
+        end
+
+        def __properties__
+          @__properties__
+        end
+      end
+
+      def is_temporal(*args, &block)
+
+        extend(Migration) if respond_to?(:auto_migrate!)
+
+        version_model = DataMapper::Model.new
+
+        if block_given?
+          version_model.instance_eval <<-RUBY
+            def self.default_repository_name
+              :#{default_repository_name}
+            end
+          RUBY
+
+          version_model.property(:id, DataMapper::Property::Serial)
+          version_model.property(:updated_at, DataMapper::Property::DateTime)
+          version_model.before(:save) { self.updated_at = DateTime.now }
+          version_model.instance_eval(&block)
+
+          const_set(:TemporalVersion, version_model)
+
+          h = PropertyHelper.new(self)
+          h.instance_eval(&block)
+
+          has n, :temporal_versions
+
+          create_methods
+
+          h.__properties__.each do |a|
+            create_temporal_reader(a[0])
+            create_temporal_writer(a[0])
+          end
+        else
+          # const_set(:TemporalVersion + args[0], version_model)
+          raise "Temporal Property pattern not supported yet"
+        end
+
+      end
+
+      private
+
+      def create_methods
+        class_eval <<-RUBY
+
+          def self.update(options={})
+            raise 'TODO'
+          end
+
+          def self.all(*args)
+            raise 'TODO'
+          end
+
+          def self.create(options={})
+            t_opts = __select_temporal_options__(options)
+            options.delete_if {|k,v| t_opts.keys.include?(k) }
+
+            base = super(options)
+            base.temporal_versions << TemporalVersion.create(t_opts) if t_opts.size > 0
+            base.save
+            base
+          end
+
+          def at(context)
+            @__at__ = context
+            self
+          end
+
+          def update(options={})
+            cur_t = __version_for_context__
+            attrs = cur_t.nil? ? {} : cur_t.attributes
+            t_opts = self.class.__select_temporal_options__(options)
+            options.delete_if {|k,v| t_opts.keys.include?(k) }
+            super(options)
+
+            self.temporal_versions <<
+                TemporalVersion.create(attrs.merge(:id => nil, :updated_at => nil).merge(t_opts))
+
+            self.save
+          end
+
+          private
+
+          def self.__select_temporal_options__(options={})
+            props = TemporalVersion.properties.map {|p| p.name}
+            temporal_opts = options.
+                select {|k,v| props.include?(k)}.
+                inject({}) {|a,b| a.merge({b[0] => b[1]}) }
+            return temporal_opts
+          end
+
+          def __version_for_context__(context=DateTime.now)
+            @__at__ ||= context
+            t = nil
+            temporal_versions.each do |n|
+              if (t.nil? or n.updated_at > t.updated_at) and n.updated_at <= @__at__
+                t = n
+              end
+            end
+            @__at__ = nil
+            t
+          end
+        RUBY
+      end
+
+      def create_temporal_reader(name)
+        class_eval <<-RUBY
+          def #{name}(context=DateTime.now)
+            t = __version_for_context__(context)
+            t.nil? ? nil : t.#{name}
+          end
+        RUBY
+      end
+
+      def create_temporal_writer(name)
+        class_eval <<-RUBY
+          def #{name}=(x)
+            t = __version_for_context__
+            attrs = t.nil? ? {} : t.attributes
+            t = TemporalVersion.create(attrs.merge(:id => nil, :updated_at => nil))
+            temporal_versions << t
+            t.#{name} = x
+            self.save
+            #{name}
+          end
+        RUBY
+      end
+
+      module Migration
+
+        def auto_migrate!(repository_name = self.repository_name)
+          super
+          self::TemporalVersion.auto_migrate!
+        end
+
+        def auto_upgrade!(repository_name = self.repository_name)
+          super
+          self::TemporalVersion.auto_upgrade!
+        end
+
+      end 
+    end
+  end
+end

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+#require 'dm-core/spec/setup'
+#require 'dm-core/spec/lib/adapter_helpers'
+
+require 'rubygems'
+require 'dm-core'
+require 'dm-is-temporal'
+require 'dm-migrations'
+
+#Spec::Runner.configure do |config|
+#  config.extend(DataMapper::Spec::Adapters::Helpers)
+#end

data/spec/temporal_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+
+class MyModel
+  include DataMapper::Resource
+
+#  def self.default_repository_name
+#    :test
+#  end
+
+  property :id, Serial
+  property :name, String
+
+  is_temporal do
+    property :foo, Integer
+    property :bar, String
+  end
+end
+
+class MyOtherRepoModel
+  include DataMapper::Resource
+
+  def self.default_repository_name
+    :test
+  end
+
+  property :id, Serial
+  property :name, String
+
+  is_temporal do
+    property :foo, Integer
+  end
+end
+
+describe DataMapper::Is::Temporal do
+
+  before(:all) do
+    DataMapper.setup(:default, "sqlite3::memory:")
+    DataMapper.setup(:test, "sqlite3::memory:")
+    DataMapper.auto_migrate!(:default)
+    DataMapper.auto_migrate!(:test)
+  end
+
+  describe "#is_temporal" do
+
+    subject do
+      MyModel.create
+    end
+
+    context "when at context" do
+      it "returns old values" do
+        subject.foo.should == nil
+        subject.foo = 42
+        subject.foo.should == 42
+
+        old = DateTime.parse('-4712-01-01T00:00:00+00:00')
+        now = DateTime.now
+
+        subject.at(old).foo.should == nil
+        subject.at(now).foo.should == 42
+      end
+    end
+
+    context "when foo is 42" do
+      it "returns 42" do
+        subject.foo.should == nil
+        subject.foo = 42
+        subject.foo.should == 42
+      end
+    end
+
+    context "when bar is 'hello'" do
+      it "returns 'hello' and then 'goodbye'" do
+        subject.bar.should == nil
+        subject.bar = 'hello'
+        subject.bar.should == 'hello'
+        subject.bar = 'goodbye'
+        subject.bar.should == 'goodbye'
+      end
+    end
+
+    context "when name is 'hello'" do
+      it "returns 'hello' and then 'goodbye'" do
+        subject.name.should == nil
+        subject.name = 'hello'
+        subject.name.should == 'hello'
+        subject.name = 'goodbye'
+        subject.name.should == 'goodbye'
+      end
+    end
+
+    context "when updated" do
+      it "all values set and reset" do
+        subject.update(
+            :foo => 42,
+            :bar => 'hello',
+            :name => 'joe'
+        )
+
+        subject.foo.should == 42
+        subject.bar.should == 'hello'
+        subject.name.should == 'joe'
+      end
+    end
+
+    context "when churnned" do
+      it "has many versions" do
+        subject.foo = 1
+        subject.foo = 2
+        subject.foo = 3
+        subject.foo = 4
+
+        subject.instance_eval {self.temporal_versions.size.should == 4}
+      end
+    end
+
+    context "when class create with options" do
+      it "return all values" do
+        m = MyModel.create(
+            :foo => 42,
+            :bar => 'hello',
+            :name => 'joe'
+        )
+
+        m.foo.should == 42
+        m.bar.should == 'hello'
+        m.name.should == 'joe'
+
+        m.foo = 10
+        m.foo.should == 10
+      end
+    end
+
+    context "when repository name is set" do
+      it "MyModel returns :default" do
+        MyModel::TemporalVersion.default_repository_name.should == :default
+      end
+
+      it "MyOtherRepoModel returns :test" do
+        MyOtherRepoModel::TemporalVersion.default_repository_name.should == :test
+      end
+
+      context "when name is 'hello'" do
+        subject do
+          MyOtherRepoModel.create
+        end
+
+        it "returns 'hello' and then 'goodbye'" do
+          subject.name.should == nil
+          subject.name = 'hello'
+          subject.name.should == 'hello'
+          subject.name = 'goodbye'
+          subject.name.should == 'goodbye'
+        end
+      end
+
+      context "when updated" do
+        it "all values set and reset" do
+          subject.update(
+              :foo => 42,
+              :name => 'joe'
+          )
+
+          subject.foo.should == 42
+          subject.name.should == 'joe'
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: dm-is-temporal
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+  - Joe Kutner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-08 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: DataMapper plugin implementing temporal patterns
+email: jpkutner [a] gmail [d] com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - LICENSE.txt
+  - README.md
+files: 
+  - Gemfile
+  - LICENSE.txt
+  - README.md
+  - Rakefile
+  - VERSION
+  - lib/dm-is-temporal.rb
+  - lib/dm-is-temporal/is/temporal.rb
+  - spec/spec.opts
+  - spec/spec_helper.rb
+  - spec/temporal_spec.rb
+has_rdoc: true
+homepage: http://github.com/jkutner/dm-is-temporal
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: DataMapper plugin implementing temporal patterns
+test_files: 
+  - spec/spec_helper.rb
+  - spec/temporal_spec.rb