ardm-sweatshop 1.2.0

data/lib/dm-sweatshop/support/class_attributes.rb

@@ -0,0 +1,46 @@
+module DataMapper
+  class Sweatshop
+    module ClassAttributes
+      def self.reader(klass, *attributes)
+        attributes.each do |attribute|
+          klass.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            unless defined? @@#{attribute}
+              @@#{attribute} = nil
+            end
+
+            def self.#{attribute}
+              @@#{attribute}
+            end
+
+            def #{attribute}
+              @@#{attribute}
+            end
+          RUBY
+        end
+      end
+
+      def self.writer(klass, *attributes)
+        attributes.each do |attribute|
+          klass.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            unless defined? @@#{attribute}
+              @@#{attribute} = nil
+            end
+
+            def self.#{attribute}=(obj)
+              @@#{attribute} = obj
+            end
+
+            def #{attribute}=(obj)
+              @@#{attribute} = obj
+            end
+          RUBY
+        end
+      end
+
+      def self.accessor(klass, *attributes)
+        self.reader(klass, *attributes)
+        self.writer(klass, *attributes)
+      end
+    end
+  end
+end

data/lib/dm-sweatshop/sweatshop.rb

@@ -0,0 +1,145 @@
+module DataMapper
+  class Sweatshop
+    # Raise when requested attributes hash or instance are not
+    # found in model and record maps, respectively.
+    #
+    # This usually happens when you forget to use +make+ or
+    # +generate+ method before trying to +pick+ an object.
+    class NoFixtureExist < StandardError
+    end
+
+    class << self
+      attr_accessor :model_map
+      attr_accessor :record_map
+    end
+
+    # Models map stores named Procs for a class.
+    # Each Proc must return a Hash of attributes.
+    self.model_map = Hash.new {|ha,ka| ha[ka] = Hash.new {|hb,kb| hb[kb] = []}}
+    # Records map stores named instances of a class.
+    # Those instances may or may not be new records.
+    self.record_map = Hash.new {|ha,ka| ha[ka] = Hash.new {|hb,kb| hb[kb] = []}}
+
+    # Adds a Proc to model map. Proc must return a Hash of attributes.
+    #
+    # @param     klass      [Class, DataMapper::Resource]
+    # @param     name       [Symbol]
+    # @param     instance   [DataMapper::Resource]
+    #
+    # @api       private
+    #
+    # @return   [Array]    model map
+    def self.add(klass, name, &proc)
+      self.model_map[klass][name.to_sym] << proc
+    end
+
+    # Adds an instance to records map.
+    #
+    # @param     klass      [Class, DataMapper::Resource]
+    # @param     name       [Symbol]
+    # @param     instance   [DataMapper::Resource]
+    #
+    # @api       private
+    #
+    # @return   [DataMapper::Resource]    added instance
+    def self.record(klass, name, instance)
+      self.record_map[klass][name.to_sym] << instance
+      instance
+    end
+
+    # Same as create but calls Model#create! and does save
+    # invalid models
+    #
+    # @param     klass       [Class, DataMapper::Resource]
+    # @param     name        [Symbol]
+    # @param     attributes  [Hash]
+    #
+    # @api       private
+    #
+    # @return   [DataMapper::Resource]    added instance
+    def self.create!(klass, name, attributes = {})
+      record(klass, name, klass.create!(attributes(klass, name).merge(attributes)))
+    end
+
+    # Creates an instance from given hash of attributes, saves it
+    # and adds it to the record map.
+    #
+    # @param     klass       [Class, DataMapper::Resource]
+    # @param     name        [Symbol]
+    # @param     attributes  [Hash]
+    #
+    # @api       private
+    #
+    # @return   [DataMapper::Resource]    added instance
+    def self.create(klass, name, attributes = {})
+      record(klass, name, klass.create(attributes(klass, name).merge(attributes)))
+    end
+
+    # Creates an instance from given hash of attributes
+    # and adds it to records map without saving.
+    #
+    # @param     klass       [Class, DataMapper::Resource]
+    # @param     name        [Symbol]
+    # @param     attributes  [Hash]
+    #
+    # @api       private
+    #
+    # @return   [DataMapper::Resource]    added instance
+    def self.make(klass, name, attributes = {})
+      record(klass, name, klass.new(attributes(klass, name).merge(attributes)))
+    end
+
+    # Returns a pre existing instance of a model from the record map
+    #
+    # @param     klass    [Class, DataMapper::Resource]
+    # @param     name     [Symbol]
+    #
+    # @return   [DataMapper::Resource]                   existing instance of a model from the record map
+    # @raise     DataMapper::Sweatshop::NoFixtureExist   when requested fixture does not exist in the record map
+    #
+    # @api       private
+    def self.pick(klass, name)
+      self.record_map[klass][name.to_sym].pick || raise(NoFixtureExist, "no #{name} context fixtures have been generated for the #{klass} class")
+    end
+
+    # Returns a Hash of attributes from the model map
+    #
+    # @param     klass    [Class, DataMapper::Resource]
+    # @param     name     [Symbol]
+    #
+    # @return   [Hash]          existing instance of a model from the model map
+    # @raise    NoFixtureExist  when requested fixture does not exist in the model map
+    #
+    # @api       private
+    def self.attributes(klass, name)
+      proc = model_map[klass][name.to_sym].pick
+
+      if proc
+        expand_callable_values(proc.call)
+      elsif klass.superclass.is_a?(DataMapper::Model)
+        attributes(klass.superclass, name)
+      else
+        raise NoFixtureExist, "#{name} fixture was not found for class #{klass}"
+      end
+    end
+
+    # Returns a Hash with callable values evaluated.
+    #
+    # @param     hash     [Hash]
+    #
+    # @return   [Hash]          existing instance of a model from the model map
+    #
+    # @api       private
+    def self.expand_callable_values(hash)
+      expanded = {}
+      hash.each do |key, value|
+        if value.respond_to?(:call)
+          expanded[key] = value.call
+        else
+          expanded[key] = value
+        end
+      end
+      expanded
+    end
+  end
+end

data/lib/dm-sweatshop/unique.rb

@@ -0,0 +1,89 @@
+require 'dm-sweatshop/support/class_attributes'
+
+module DataMapper
+  class Sweatshop
+    module Unique
+      # Yields a value to the block. The value is unique for each invocation
+      # with the same block. Alternatively, you may provide an explicit key to
+      # identify the block.
+      #
+      # If a block with no parameter is supplied, unique keeps track of previous
+      # invocations, and will continue yielding until a unique value is generated.
+      # If a unique value is not generated after @UniqueWorker::MAX_TRIES@, an exception
+      # is raised.
+      #
+      # ParseTree is required unless an explicit key is provided
+      #
+      #   (1..3).collect { unique {|x| x }}     # => [0, 1, 2]
+      #   (1..3).collect { unique {|x| x + 1 }} # => [1, 2, 3]
+      #   (1..3).collect { unique {|x| x }}     # => [3, 4, 5] # Continued on from above
+      #   (1..3).collect { unique(:a) {|x| x }} # => [0, 1, 2] # Explicit key overrides block identity
+      #
+      #   a = [1, 1, 1, 2, 2, 3]
+      #   (1..3).collect { unique { a.shift }}  # => [1, 2, 3]
+      #   (1..3).collect { unique { 1 }}        # raises TooManyTriesException
+      #
+      # return <Object> the return value of the block
+      def unique(key = nil, &block)
+        if block.arity < 1
+          UniqueWorker.unique_map ||= {}
+
+          key ||= UniqueWorker.key_for(&block)
+          set = UniqueWorker.unique_map[key] || Set.new
+          result = block[]
+          tries = 0
+          while set.include?(result)
+            result = block[]
+            tries += 1
+
+            raise TooManyTriesException.new("Could not generate unique value after #{tries} attempts") if tries >= UniqueWorker::MAX_TRIES
+          end
+          set << result
+          UniqueWorker.unique_map[key] = set
+        else
+          UniqueWorker.count_map ||= Hash.new() { 0 }
+
+          key ||= UniqueWorker.key_for(&block)
+          result = block[UniqueWorker.count_map[key]]
+          UniqueWorker.count_map[key] += 1
+        end
+
+        result
+      end
+
+      class TooManyTriesException < RuntimeError; end;
+    end
+    extend(Unique)
+
+    class UniqueWorker
+      MAX_TRIES = 10
+
+      unless defined?(JRUBY_VERSION) || RUBY_VERSION >= '1.9'
+        begin
+          gem 'ParseTree', '~>3.0.3'
+          require 'parse_tree'
+        rescue LoadError
+          puts 'DataMapper::Sweatshop::Unique - ParseTree could not be loaded, anonymous uniques will not be allowed'
+        end
+      end
+
+      ClassAttributes.accessor(self, :count_map)
+      ClassAttributes.accessor(self, :unique_map)
+      ClassAttributes.accessor(self, :parser)
+
+      # Use the sexp representation of the block as a unique key for the block
+      # If you copy and paste a block, it will still have the same key
+      #
+      # return <Object> the unique key for the block
+      def self.key_for(&block)
+        raise "You need to install ParseTree to use anonymous an anonymous unique (gem install ParseTree). In the mean time, explicitly declare a key: unique(:my_key) { ... }" unless Object::const_defined?("ParseTree")
+
+        klass = Class.new
+        name = "tmp"
+        klass.send(:define_method, name, &block)
+        self.parser ||= ParseTree.new(false)
+        self.parser.parse_tree_for_method(klass, name).last
+      end
+    end
+  end
+end

data/lib/dm-sweatshop/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  class Sweatshop
+    VERSION = '1.2.0'
+  end
+end

data/spec/dm-sweatshop/model_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+
+describe DataMapper::Model do
+
+  class Widget
+    include DataMapper::Resource
+    property :id, Serial
+    property :type, Discriminator
+    property :name, String
+    property :price, Integer
+
+    belongs_to :order, :required => false
+    validates_presence_of :price
+  end
+
+  class Wonket < Widget
+    property :size, String
+  end
+
+  class Order
+    include DataMapper::Resource
+
+    property :id, Serial
+
+    has n, :widgets
+  end
+
+  before(:each) do
+    DataMapper.auto_migrate!
+    DataMapper::Sweatshop.model_map.clear
+    DataMapper::Sweatshop.record_map.clear
+  end
+
+  supported_by :all do
+
+    describe ".default_fauxture_name" do
+      it "is :default" do
+        Order.default_fauxture_name.should == :default
+      end
+    end
+
+    describe ".fixture" do
+      describe "without fauxture name" do
+        before :each do
+          Widget.fixture {{
+            :name => /\w+/.gen.capitalize,
+            :price => /\d{4,5}/.gen.to_i
+          }}
+
+          @default = DataMapper::Sweatshop.model_map[Widget][:default]
+        end
+
+        it "add a fixture proc for the model with name :default" do
+          @default.should_not be_empty
+          @default.first.should be_kind_of(Proc)
+        end
+      end
+
+      it "should allow handle complex named fixtures" do
+        Wonket.fix {{
+          :name => /\w+ Wonket/.gen.capitalize,
+          :price => /\d{2,3}99/.gen.to_i,
+          :size => %w[small medium large xl].pick
+        }}
+
+        Order.fix {{
+          :widgets => (1..5).of { Widget.gen }
+        }}
+
+        Order.fix(:wonket_order) {{
+          :widgets => (5..10).of { Wonket.gen }
+        }}
+
+        wonket_order = Order.gen(:wonket_order)
+        wonket_order.widgets.should_not be_empty
+      end
+
+      it "should allow for STI fixtures" do
+        Widget.fix {{
+          :name => /\w+/.gen.capitalize,
+          :price => /\d{4,5}/.gen.to_i
+        }}
+
+        Order.fix {{
+          :widgets => (1..5).of { Wonket.gen }
+        }}
+
+        Order.gen.widgets.should_not be_empty
+      end
+    end
+
+    describe ".make" do
+      before :each do
+        Widget.fix(:red) {{
+          :name  => "red",
+          :price => 20
+        }}
+
+        @widget = Widget.make(:red)
+      end
+
+      it "creates an object from named attributes hash" do
+        @widget.name.should == "red"
+        @widget.price.should == 20
+      end
+
+      it "returns a new object" do
+        @widget.should be_new
+      end
+    end
+
+    describe ".generate" do
+      before :each do
+        Widget.fix(:red) {{
+          :name  => "red",
+          :price => 20
+        }}
+
+        @widget = Widget.gen(:red)
+
+        Widget.fix(:blue) {{
+          :name  => "blue"
+        }}
+      end
+
+      it "creates an object from named attributes hash" do
+        @widget.name.should == "red"
+        @widget.price.should == 20
+      end
+
+      it "returns a saved object" do
+        @widget.should be_saved
+      end
+
+      it "does not save invalid model" do
+        blue_widget = Widget.gen(:blue)
+        blue_widget.should be_new
+      end
+    end
+
+    describe ".generate!" do
+      it "saves a model even if it is invalid" do
+        Widget.fix(:blue) {{
+          :name  => "blue"
+        }}
+
+        blue_widget = Widget.gen!(:blue)
+        blue_widget.should be_saved
+      end
+    end
+
+    describe ".pick" do
+      before :each do
+        Widget.fix(:red) {{
+          :name  => "rosso",
+          :price => 20
+        }}
+
+        Widget.fix(:yellow) {{
+          :name  => "giallo",
+          :price => 30
+        }}
+
+        Widget.fix(:blue) {{
+          :name  => Proc.new { "b" + "lu" },
+          :price => 40
+        }}
+
+        @red    = Widget.gen(:red)
+        @yellow = Widget.gen(:yellow)
+        @blue   = Widget.gen(:blue)
+      end
+
+      it "returns a pre existing object with named attributes hash" do
+        @red.name.should == "rosso"
+        @red.price.should == 20
+
+        @yellow.name.should == "giallo"
+        @yellow.price.should == 30
+      end
+
+      it "expands callable values of attributes hash" do
+        @blue.name.should == "blu"
+      end
+    end
+
+    describe ".generate_attributes" do
+      before :each do
+        Widget.fix(:red) {{
+          :name  => "red",
+          :price => 20
+        }}
+
+        @hash = Widget.generate_attributes(:red)
+      end
+
+      it "returns a Hash" do
+        @hash.should be_an_instance_of(Hash)
+      end
+
+      it "returns stored attributes hash by name" do
+        @hash[:name].should == "red"
+        @hash[:price].should == 20
+      end
+    end
+
+  end
+
+end