blueprints 0.6.3 → 0.7.1

data/lib/blueprints/{plan.rb → blueprint.rb}

@@ -1,15 +1,15 @@
 module Blueprints
   # Class for actual blueprints. Allows building itself by executing block passed against current context.
-  class Plan < Buildable
+  class Blueprint < Buildable
     # Initializes blueprint by name and block
     def initialize(name, &block)
       super(name)
       @block = block
     end
 
-    # Builds plan and adds it to executed plan hash. Setups instance variable with same name as plan if it is not defined yet.
+    # Builds blueprint and adds it to executed blueprint hash. Setups instance variable with same name as blueprint if it is not defined yet.
     def build_self(build_once = true)
-      if build_once and Namespace.root.executed_plans.include?(path)
+      if build_once and Namespace.root.executed_blueprints.include?(path)
         Blueprints.warn("Building with options, but blueprint was already built", @name) if Namespace.root.context.options.present?
       else
         surface_errors do
@@ -19,7 +19,7 @@ module Blueprints
           end
         end
       end
-      Namespace.root.executed_plans << path
+      Namespace.root.executed_blueprints << path
       @result
     end
 

data/lib/blueprints/buildable.rb

@@ -74,7 +74,7 @@ module Blueprints
       @parents.each do |p|
         parent = begin
           namespace[p]
-        rescue PlanNotFoundError
+        rescue BlueprintNotFoundError
           Namespace.root[p]
         end
 
@@ -90,7 +90,7 @@ module Blueprints
           name = name.to_sym unless name == ''
           return name, []
         else
-          raise TypeError, "Pass plan names as strings or symbols only, cannot build plan #{name.inspect}"
+          raise TypeError, "Pass blueprint names as strings or symbols only, cannot define blueprint #{name.inspect}"
       end
     end
   end

data/lib/blueprints/configuration.rb

@@ -0,0 +1,42 @@
+module Blueprints
+  class Configuration
+    SUPPORTED_ORMS = [nil, :active_record]
+    # Allows passing custom filename pattern in case blueprints are held in place other than spec/blueprint, test/blueprint, blueprint.
+    attr_accessor :filename
+    # Allows passing scenarios that should be prebuilt and available in all tests. Works similarly to fixtures.
+    attr_accessor :prebuild
+    # Allows passing custom root folder to use in case of non rails project. Defaults to RAILS_ROOT or current folder if RAILS_ROOT is not defined.
+    attr_accessor :root
+    # By default blueprints runs each test in it's own transaction. This may sometimes be not desirable so this options allows to turn this off.
+    attr_accessor :transactions
+    # Returns ORM that is used, default is :active_record
+    attr_reader :orm
+
+    # Sets default attributes for all attributes
+    def initialize
+      @filename = [nil, "spec", "test"].map do |dir|
+        ["blueprint"].map do |file|
+          path = File.join([dir, file].compact)
+          ["#{path}.rb", File.join(path, "*.rb")]
+        end
+      end.flatten
+      @orm = :active_record
+      @prebuild = []
+      @transactions = true
+      @root = if defined?(RAILS_ROOT)
+        RAILS_ROOT
+      else
+        nil
+      end
+    end
+
+    # Allows specifying what ORM should be used. See SUPPORTED_ORMS to check what values it can contain.
+    def orm=(value)
+      if SUPPORTED_ORMS.include?(value)
+        @orm = value
+      else
+        raise ArgumentError, "Unsupported ORM #{value.inspect}. Blueprints supports only #{SUPPORTED_ORMS.collect(&:inspect).join(', ')}"
+      end
+    end
+  end
+end

data/lib/blueprints/convertable.rb

@@ -0,0 +1,30 @@
+module Blueprints
+  module Convertable
+    def persist(str)
+      File.open(@output_file, 'a+') do |f|
+        f.write(str)
+      end
+    end
+    
+    def process!
+      persist "#{banner_start}#{convert}#{banner_end}"
+    end
+    
+    def banner_start
+      "### blueprints from #{@format}\n\n"
+    end
+    
+    def banner_end
+      "\n###\n" 
+    end
+  end
+
+  class Converter
+    def self.for(format, options = {})
+      require "blueprints/convertable/#{format}"
+      Class.new("Blueprints::#{format.capitalize}Converter".constantize) do |options|
+        include Convertable
+      end
+    end
+  end
+end

data/lib/blueprints/convertable/fixtures.rb

@@ -0,0 +1,43 @@
+module Blueprints
+  class FixturesConverter
+    def initialize(options = {})
+      @format = "fixtures"
+      @source_files = options[:source_files]
+      @output_file = options[:output_file]
+      @blueprints_data = ""
+      
+      raise "No source files given" unless @source_files
+      raise "No output file given" unless @output_file
+    end
+    
+    def convert
+      @source_files.each do |fixture_file|
+        klass = File.basename(fixture_file, '.yml').singularize.capitalize
+
+        loaded_yaml = YAML.load(File.read(fixture_file))
+
+        @blueprints_data = loaded_yaml.collect do |title,yaml_obj|
+          params = yaml_obj.collect do |k,v|
+            ":#{k} => #{parameterize(v)}"
+          end.join(', ')
+
+          "#{klass}.blueprint(:#{title}, {#{params}})\n"
+        end
+      end
+      
+      @blueprints_data
+    end
+
+    def parameterize(object)
+      if object =~ /<%=\s+?(.+)\s+%>/
+        '('+$1+')'
+      elsif object.is_a?(String)
+        (%Q(#{object})).inspect
+      elsif object.nil?
+        'nil'
+      else
+        object.to_s
+      end
+    end
+  end
+end

data/lib/blueprints/database_backends/active_record.rb

@@ -1,94 +1,53 @@
 module Blueprints
-  module DatabaseBackends
-    class ActiveRecord
-      DELETE_POLICIES = {:delete => "DELETE FROM %s", :truncate => "TRUNCATE %s"}
-
-      # Extends active record with blueprint method
-      def initialize
-        ::ActiveRecord::Base.send(:include, ActiveRecordExtensions::Instance)
-        ::ActiveRecord::Base.extend(ActiveRecordExtensions::Class)
-      end
-
-      # Starts new transaction and marks it as unjoinable so that test case could use transactions too.
-      def start_transaction
-        ::ActiveRecord::Base.connection.increment_open_transactions
-        ::ActiveRecord::Base.connection.transaction_joinable = false
-        ::ActiveRecord::Base.connection.begin_db_transaction
-      end
-
-      # Rollbacks transaction
-      def rollback_transaction
-        ::ActiveRecord::Base.connection.rollback_db_transaction
-        ::ActiveRecord::Base.connection.decrement_open_transactions
-      end
-
-      # Clears all tables using delete policy specified. Also accepts list of tables to delete.
-      def delete_tables(delete_policy, *args)
-        delete_policy ||= :delete
-        raise ArgumentError, "Unknown delete policy #{delete_policy}" unless DELETE_POLICIES.keys.include?(delete_policy)
-        args = tables if args.blank?
-        args.each { |t| ::ActiveRecord::Base.connection.delete(DELETE_POLICIES[delete_policy] % t) }
-      end
-
-      # Returns all tables without skipped ones.
-      def tables
-        ::ActiveRecord::Base.connection.tables - skip_tables
-      end
-
-      # Returns tables that should never be cleared (those that contain migrations information).
-      def skip_tables
-        %w( schema_info schema_migrations )
-      end
-
-      # Extensions for active record class
-      module ActiveRecordExtensions
-        module Class
-          # Two forms of this method can be used. First one is typically used inside blueprint block. Essentially it does
-          # same as <tt>create!</tt>, except it does bypass attr_protected and attr_accessible. It accepts only a hash or attributes,
-          # same as <tt>create!</tt> does.
-          #   blueprint :post => :user do
-          #     @user.posts.blueprint(:title => 'first post', :text => 'My first post')
-          #   end
-          # The second form is used when you want to define new blueprint. It takes first argument as name of blueprint
-          # and second one as hash of attributes. As you cannot use instance variables outside of blueprint block, you need
-          # to prefix them with colon. So the example above could be rewritten like this:
-          #   Post.blueprint(:post, :title => 'first post', :text => 'My first post', :user => d(:user))
-          # or like this:
-          #   Post.blueprint(:post, :title => 'first post', :text => 'My first post', :user => :@user).depends_on(:user)
-          # or like this:
-          #   Post.blueprint({:post => :user}, :title => 'first post', :text => 'My first post', :user => :@user)
-          def blueprint(name_or_attrs, attrs = {})
-            if Blueprints::FileContext.evaluating
-              klass = self
-              blueprint = Blueprints::Plan.new(name_or_attrs) { klass.blueprint attributes }
-              blueprint.depends_on(*attrs.values.select {|attr| attr.is_a?(Blueprints::Buildable::Dependency) }).attributes(attrs)
-              blueprint
-            else
-              if name_or_attrs.is_a?(Array)
-                name_or_attrs.collect { |attrs| blueprint(attrs) }
-              else
-                object = new
-                object.blueprint(name_or_attrs)
-                object
-              end
-            end
+  # Extensions for active record class
+  module ActiveRecordExtensions
+    module ClassMethods
+      # Two forms of this method can be used. First one is typically used inside blueprint block. Essentially it does
+      # same as <tt>create!</tt>, except it does bypass attr_protected and attr_accessible. It accepts only a hash or attributes,
+      # same as <tt>create!</tt> does.
+      #   blueprint :post => :user do
+      #     @user.posts.blueprint(:title => 'first post', :text => 'My first post')
+      #   end
+      # The second form is used when you want to define new blueprint. It takes first argument as name of blueprint
+      # and second one as hash of attributes. As you cannot use instance variables outside of blueprint block, you need
+      # to prefix them with colon. So the example above could be rewritten like this:
+      #   Post.blueprint(:post, :title => 'first post', :text => 'My first post', :user => d(:user))
+      # or like this:
+      #   Post.blueprint(:post, :title => 'first post', :text => 'My first post', :user => :@user).depends_on(:user)
+      # or like this:
+      #   Post.blueprint({:post => :user}, :title => 'first post', :text => 'My first post', :user => :@user)
+      def blueprint(name_or_attrs, attrs = {})
+        if Blueprints::FileContext.evaluating
+          klass = self
+          blueprint = Blueprints::Blueprint.new(name_or_attrs) { klass.blueprint attributes }
+          blueprint.depends_on(*attrs.values.select {|attr| attr.is_a?(Blueprints::Buildable::Dependency) }).attributes(attrs)
+          blueprint
+        else
+          if name_or_attrs.is_a?(Array)
+            name_or_attrs.collect { |attrs| blueprint(attrs) }
+          else
+            object = new
+            object.blueprint(name_or_attrs)
+            object
           end
         end
+      end
+    end
 
-        module Instance
-          # Updates attributes of object and calls save!. Bypasses attr_protected and attr_accessible.
-          def blueprint(attributes)
-            attributes.each do |attr, value|
-              iv_name = value.iv_name if value.is_a?(Blueprints::Buildable::Dependency)
-              iv_name = value if value.is_a? Symbol and value.to_s =~ /^@.+$/
-              attributes[attr] = Blueprints::Namespace.root.context.instance_variable_get(iv_name) if iv_name
-            end
-            send(:attributes=, attributes, false)
-            save!
-          end
+    module InstanceMethods
+      # Updates attributes of object and calls save!. Bypasses attr_protected and attr_accessible.
+      def blueprint(attributes)
+        attributes.each do |attr, value|
+          iv_name = value.iv_name if value.is_a?(Blueprints::Buildable::Dependency)
+          iv_name = value if value.is_a? Symbol and value.to_s =~ /^@.+$/
+          attributes[attr] = Blueprints::Namespace.root.context.instance_variable_get(iv_name) if iv_name
         end
+        send(:attributes=, attributes, false)
+        save!
       end
-
     end
   end
 end
+
+::ActiveRecord::Base.send(:include, Blueprints::ActiveRecordExtensions::InstanceMethods)
+::ActiveRecord::Base.extend(Blueprints::ActiveRecordExtensions::ClassMethods)

data/lib/blueprints/errors.rb

@@ -1,12 +1,12 @@
 module Blueprints
   # Is raised when blueprint or namespace is not found.
-  class PlanNotFoundError < NameError
+  class BlueprintNotFoundError < NameError
     def initialize(*args)
-      @plans = args
+      @blueprints = args
     end
 
     def to_s
-      "Plan/namespace not found '#{@plans.join(',')}'"
+      "Blueprint/namespace not found '#{@blueprints.join(',')}'"
     end
   end
 end

data/lib/blueprints/extensions/deprecated.rb

@@ -0,0 +1,22 @@
+module EnableBlueprints #:nodoc:
+  def enable_blueprints(options = {})
+    STDERR.puts "DEPRECATION WARNING: enable_blueprints is deprecated. Use Blueprints.enable"
+    Blueprints.enable do |config|
+      options.each {|option, value| config.send("#{option}=", value) }
+    end
+  end
+end
+
+module ActiveSupport #:nodoc:all
+  class TestCase
+    include EnableBlueprints
+  end
+end if defined? ActiveSupport::TestCase
+
+module Spec #:nodoc:all
+  module Runner
+    class Configuration
+      include EnableBlueprints
+    end
+  end
+end if defined? Spec or $0 =~ /script.spec$/

data/lib/blueprints/extensions/rspec.rb

@@ -1,35 +1,10 @@
-# Module that gets included into RSpec Configuration class to provide enable_blueprints method.
-module Blueprints::RspecMixin
-  # Enables blueprints in rspec. Is automatically added if <tt>Spec</tt> is defined at loading time or <tt>script/spec</tt>
-  # is used. You might need to require it manually in certain case (eg. running specs from metrics).
-  # Accepts options hash. For supported options please check Blueprints.load.
-  def enable_blueprints(options = {})
-    Blueprints.load(options)
-
-    include(Blueprints::Helper)
-    before do
-      Blueprints.setup(self)
-    end
-    after do
-      Blueprints.teardown
-    end
+config_class = defined?(RSpec) ? RSpec : Spec::Runner
+config_class.configure do |config|
+  config.include(Blueprints::Helper)
+  config.before do
+    Blueprints.setup(self)
   end
-end
-
-if defined?(RSpec)
-  module RSpec #:nodoc:
-    module Core #:nodoc:
-      class Configuration
-        include  Blueprints::RspecMixin
-      end
-    end
-  end
-else
-  module Spec #:nodoc:
-    module Runner #:nodoc:
-      class Configuration
-        include Blueprints::RspecMixin
-      end
-    end
+  config.after do
+    Blueprints.teardown
   end
 end

data/lib/blueprints/extensions/test_unit.rb

@@ -1,21 +1,12 @@
-module Test #:nodoc:
-  module Unit #:nodoc:
-    class TestCase
-      # Runs tests with blueprints support
-      def run_with_blueprints(result, &progress_block)
-        Blueprints.setup(self)
-        run_without_blueprints(result, &progress_block)
-        Blueprints.teardown
-      end
-
-      # Enables blueprints in test/unit. Is automatically added if <tt>Spec</tt> is not defined at loading time.
-      # You might need to require it manually in certain case (eg. using both rspec and test/unit).
-      # Accepts options hash. For supported options please check Blueprints.load.
-      def self.enable_blueprints(options = {})
-        include Blueprints::Helper
-        Blueprints.load(options)
-        alias_method_chain :run, :blueprints
-      end
+module ActiveSupport #:nodoc:all
+  class TestCase
+    include Blueprints::Helper
+    # Runs tests with blueprints support
+    def run_with_blueprints(result, &progress_block)
+      Blueprints.setup(self)
+      run_without_blueprints(result, &progress_block)
+      Blueprints.teardown
     end
+    alias_method_chain :run, :blueprints
   end
 end

data/lib/blueprints/file_context.rb

@@ -3,9 +3,9 @@ module Blueprints
   module FileContext
     mattr_accessor :evaluating
 
-    # Creates a new plan by name and block passed
-    def self.blueprint(plan, &block)
-      Plan.new(plan, &block)
+    # Creates a new blueprint by name and block passed
+    def self.blueprint(name, &block)
+      Blueprint.new(name, &block)
     end
 
     # Creates new namespace by name, and evaluates block against it.

data/lib/blueprints/helper.rb

@@ -37,17 +37,19 @@ module Blueprints
     #
     # TODO: add sample usage
     def demolish(*args)
+      STDERR.puts "DEPRECATION WARNING: demolish is deprecated and will be changed to support per blueprint demolishing in blueprints 0.8.0"
       options = args.extract_options!
-      Blueprints.delete_tables(*args)
+      args = (ActiveRecord::Base.connection.tables - ['schema_migrations']) if args.blank?
+      args.each {|table| ActiveRecord::Base.connection.execute("DELETE FROM #{table}") }
 
       if options[:undo] == :all
-        Namespace.root.executed_plans.clear
+        Namespace.root.executed_blueprints.clear
       else
         undo = [options[:undo]].flatten.compact.collect {|bp| bp.to_s }
-        unless (not_found = undo - Namespace.root.executed_plans.to_a).blank?
-          raise(PlanNotFoundError, not_found)
+        unless (not_found = undo - Namespace.root.executed_blueprints.to_a).blank?
+          raise(BlueprintNotFoundError, not_found)
         end
-        Namespace.root.executed_plans -= undo
+        Namespace.root.executed_blueprints -= undo
       end
     end
   end