fedux_org-stdlib 0.3.2 → 0.6.3

data/spec/project/plan_spec.rb

@@ -1,12 +1,13 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'fedux_org/stdlib/project/plan'
+require 'fedux_org_stdlib/project/plan'
 
-describe FeduxOrg::Stdlib::Project::Plan do
-  context '#file' do
+RSpec.describe FeduxOrgStdlib::Project::Plan do
+  context '#to_s' do
     it 'uses the working directory by default to find plan' do 
       switch_to_working_directory do
-        plan = FeduxOrg::Stdlib::Project::Plan.new
-        expect( plan.file ).to eq( File.join( Dir.getwd , 'plan.tjp' ) )
+        plan = FeduxOrgStdlib::Project::Plan.new
+        expect(plan.to_s).to eq(File.join(Dir.getwd , 'plan.tjp'))
       end
     end
   end

data/spec/project/report_spec.rb

@@ -1,53 +1,60 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'fedux_org/stdlib/project/report'
-require 'fedux_org/stdlib/filesystem'
+require 'fedux_org_stdlib/project/report'
+require 'fedux_org_stdlib/filesystem'
 
-describe FeduxOrg::Stdlib::Project::Report do
+RSpec.describe FeduxOrgStdlib::Project::Report do
   context '#generate' do
-
     it 'generates report' do
-      plan = double( 'Plan' )
-      allow( plan ).to receive( :file ).and_return { create_file( 'plan.tjp' ) }
+      plan_file = create_file('plan.tjp')
+      report_file = create_file('reports/Overview.html')
+
+      plan = double('Plan')
+      allow(plan).to receive(:to_s).and_return(plan_file)
+      expect(plan).to receive(:needs_to_be_compiled?).with(report_file).and_return(true)
 
-      generator = double( 'Generator' )
-      expect( generator ).to receive( :generate_report )
+      generator = double('Generator')
+      expect(generator).to receive(:generate_report)
 
-      report = FeduxOrg::Stdlib::Project::Report.new( plan, generator )
+      report = FeduxOrgStdlib::Project::Report.new(plan: plan, generator: generator, output_file: report_file)
       report.generate
     end
 
     it 'generates report only if plan file is newer than output file' do
-      plan_file   = create_file( 'plan.tjp' ) 
-      report_file = create_file( 'reports/Overview.html' )
+      plan_file   = create_file('plan.tjp') 
+      report_file = create_file('reports/Overview.html')
 
       FileUtils.touch report_file, :mtime => Time.now - 2.hours
 
-      plan = double( 'Plan' )
-      allow( plan ).to receive( :file ).and_return {plan_file }
+      plan = double('Plan')
+      allow(plan).to receive(:to_s).and_return(plan_file)
+      expect(plan).to receive(:needs_to_be_compiled?).with(report_file).and_return(true)
 
-      generator = double( 'Generator' )
-      expect( generator ).to receive( :generate_report ).once
+      generator = double('Generator')
+      expect(generator).to receive(:generate_report).once
 
       switch_to_working_directory do
-        report = FeduxOrg::Stdlib::Project::Report.new( plan, generator )
+        report = FeduxOrgStdlib::Project::Report.new(plan: plan, generator: generator, output_file: report_file)
         report.generate
       end
     end
 
     it 'does not generate report if plan file is older or of eqal age than output file' do
-      plan_file   = create_file( 'plan.tjp' ) 
-      report_file = create_file( 'reports/Overview.html' )
+      plan_file   = create_file('plan.tjp') 
+      report_file = create_file('reports/Overview.html')
 
       FileUtils.touch plan_file, :mtime => Time.now - 2.hours
 
-      plan = double( 'Plan' )
-      allow( plan ).to receive( :file ).and_return { plan_file }
+      plan = double('Plan')
+      expect(plan).to receive(:needs_to_be_compiled?).with(report_file).and_return(false)
 
-      generator = double( 'Generator' )
+      generator = double('Generator')
+      expect(generator).not_to receive(:generate_report)
 
       switch_to_working_directory do
-        report = FeduxOrg::Stdlib::Project::Report.new( plan, generator )
-        silence( :stderr ) do
+        report = FeduxOrgStdlib::Project::Report.new(plan: plan, generator: generator, output_file: report_file)
+
+        silence(:stderr) do
           report.generate
         end
       end
@@ -56,13 +63,12 @@ describe FeduxOrg::Stdlib::Project::Report do
 
   context '#open' do
     it 'can open a report in a browser' do
-      plan = double( 'Plan' )
-      generator = double( 'Generator' )
-      report = FeduxOrg::Stdlib::Project::Report.new( plan, generator )
+      plan = double('Plan')
+      generator = double('Generator')
+      report_file = create_file('reports/Overview.html')
 
-      expect(
-        report.respond_to? :open
-      ).to be_true
+      report = FeduxOrgStdlib::Project::Report.new(plan: plan, generator: generator, output_file: report_file)
+      expect(report).to respond_to :open
     end
   end
 end

data/spec/project/taskjuggler_spec.rb

@@ -1,31 +1,32 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'fedux_org/stdlib/project/generators/taskjuggler'
+require 'fedux_org_stdlib/project/generators/taskjuggler'
 
-describe FeduxOrg::Stdlib::Project::Generators::Taskjuggler do
+RSpec.describe FeduxOrgStdlib::Project::Generators::Taskjuggler do
   context '#generate_report' do
     it "generates a report using taskjuggler" do
-      directory = create_directory( 'projects' )
-      plan_file = File.join( examples_directory, 'project', 'plan.tjp' )
+      directory = create_directory('projects')
+      plan_file = File.join(examples_directory, 'project', 'plan.tjp')
 
-      generator = FeduxOrg::Stdlib::Project::Generators::Taskjuggler.new
+      generator = FeduxOrgStdlib::Project::Generators::Taskjuggler.new
 
       switch_to_working_directory do
-        silence( :stderr ) do
-          generator.generate_report( directory, plan_file )
+        silence(:stderr) do
+          generator.generate_report(directory, plan_file)
         end
       end
     end
 
     it "fails if an error occured while generating the report" do
-      directory = create_directory( 'projects' )
-      plan_file = File.join( examples_directory, 'project', 'plan_does_not_exist.tjp' )
+      directory = create_directory('projects')
+      plan_file = File.join(examples_directory, 'project', 'plan_does_not_exist.tjp')
 
-      generator = FeduxOrg::Stdlib::Project::Generators::Taskjuggler.new
+      generator = FeduxOrgStdlib::Project::Generators::Taskjuggler.new
 
       expect {
         switch_to_working_directory do
-          silence( :stderr) do
-            generator.generate_report( directory, plan_file )
+          silence(:stderr) do
+            generator.generate_report(directory, plan_file)
           end
 
         end

data/spec/spec_helper.rb

@@ -1,46 +1,23 @@
-#encoding: utf-8
-$LOAD_PATH << File.expand_path( '../../lib', __FILE__ )
+# encoding: utf-8
+#
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+require 'fedux_org_stdlib'
+# Avoid writing "describe MyModule::MyClass do [..]" but "describe MyClass do [..]"
+include FeduxOrgStdlib
 
-unless ENV['CI'] == 'true'
-  require 'pry'
-  require 'debugger'
-  require 'ap'
-  require 'benchmark'
-end
+require 'simplecov'
+SimpleCov.command_name 'rspec'
+SimpleCov.start
 
-unless ENV['CI'] == 'true'
-  require 'simplecov'
-  SimpleCov.start
-  SimpleCov.command_name 'rspec'
-end
+# Pull in all of the gems including those in the `test` group
+require 'bundler'
+Bundler.require :default, :test, :development
 
-require 'fedux_org/stdlib'
-include FeduxOrg::Stdlib
+# Loading support files
+Dir.glob(::File.expand_path('../support/*.rb', __FILE__)).each { |f| require_relative f }
 
-RSpec.configure do |c|
-  c.treat_symbols_as_metadata_keys_with_true_values = true
-  c.filter_run :focus => true
-  c.run_all_when_everything_filtered = true
-end
 
 def examples_dir
-  File.expand_path( '../examples', __FILE__ )
+  File.expand_path('../examples', __FILE__)
 end
 alias :examples_directory :examples_dir 
-
-
-require 'fedux_org/stdlib/filesystem'
-include FeduxOrg::Stdlib::Filesystem
-
-def root_directory
-  FeduxOrg::Stdlib.root_directory 
-end
-
-RSpec.configure do |c|
-  c.before( :each ) do
-    cleanup_working_directory
-  end
-end
-
-require 'active_support/core_ext/kernel/reporting'
-require 'active_support/core_ext/string/strip'

data/spec/support/environment.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/environment'
+
+module FeduxOrgStdlib
+  module SpecHelper
+    module Environment
+      include FeduxOrgStdlib::Environment
+      alias_method :with_environment, :isolated_environment 
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include FeduxOrgStdlib::SpecHelper::Environment
+end
+

data/spec/support/filesystem.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/filesystem'
+
+module FeduxOrgStdlib
+  module SpecHelper
+    module Filesystem
+      include FeduxOrgStdlib::Filesystem
+
+      def root_directory
+        ::File.expand_path('../../../', __FILE__)
+      end
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include FeduxOrgStdlib::SpecHelper::Filesystem
+  c.before(:each) { cleanup_working_directory }
+end

data/spec/support/reporting.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'active_support/core_ext/kernel/reporting'

data/spec/support/rspec.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+RSpec.configure do |c|
+  c.filter_run_including :focus => true
+  c.run_all_when_everything_filtered = true
+end

data/spec/support/string.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'active_support/core_ext/string/strip'

data/spec/version_management/library_builder_spec.rb

@@ -1,11 +1,12 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'fedux_org/stdlib/version_management/library_builder'
+require 'fedux_org_stdlib/version_management/library_builder'
 
-describe FeduxOrg::Stdlib::VersionManagement::LibraryBuilder do
+RSpec.describe FeduxOrgStdlib::VersionManagement::LibraryBuilder do
   context '#build_from' do
     it 'accepts a version string and builds a version object' do
-      library = FeduxOrg::Stdlib::VersionManagement::LibraryBuilder.new.build_from( [ 'MyModules' ] )
-      expect( library.module_names ).to eq( [ 'MyModules' ] )
+      library = FeduxOrgStdlib::VersionManagement::LibraryBuilder.new.build_from([ 'MyModules' ])
+      expect(library.module_names).to eq([ 'MyModules' ])
     end
   end
 end

data/spec/version_management/ruby_library_spec.rb

@@ -1,11 +1,12 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'fedux_org/stdlib/version_management/ruby_library'
+require 'fedux_org_stdlib/version_management/ruby_library'
 
-describe FeduxOrg::Stdlib::VersionManagement::RubyLibrary do
+RSpec.describe FeduxOrgStdlib::VersionManagement::RubyLibrary do
   context '#module_names' do
     it 'nows about module names' do
-      lib = FeduxOrg::Stdlib::VersionManagement::RubyLibrary.new( ['MyModule', 'MyClass' ] )
-      expect( lib.module_names ).to eq( ['MyModule', 'MyClass' ] )
+      lib = FeduxOrgStdlib::VersionManagement::RubyLibrary.new(['MyModule', 'MyClass' ])
+      expect(lib.module_names).to eq(['MyModule', 'MyClass' ])
     end
   end
 end

data/spec/version_management/rubygem_version_file_parser_spec.rb

@@ -1,41 +1,41 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'fedux_org/stdlib/version_management/rubygem_version_file_parser'
+require 'fedux_org_stdlib/version_management/rubygem_version_file_parser'
 
-describe FeduxOrg::Stdlib::VersionManagement::RubygemVersionFileParser do
-
-  let( :parser ) { FeduxOrg::Stdlib::VersionManagement::RubygemVersionFileParser.new }
+RSpec.describe FeduxOrgStdlib::VersionManagement::RubygemVersionFileParser do
+  let(:parser) { FeduxOrgStdlib::VersionManagement::RubygemVersionFileParser.new }
 
   context '#parse' do
     it 'extracts version number' do
-      version_file = create_file( 'version.rb', <<-EOS.strip_heredoc
+      version_file = create_file('version.rb', <<-EOS.strip_heredoc
                                  #main MyLibrary
                                  module MyLibrary
                                    VERSION = '0.0.0'
                                  end
                                  EOS
-                                )
+                               )
 
-      parser.parse( version_file )
+      parser.parse(version_file)
 
-      expect( parser.version ).to eq( '0.0.0' )
+      expect(parser.version).to eq('0.0.0')
     end
 
     it 'extracts modules' do
-      version_file = create_file( 'version.rb', <<-EOS.strip_heredoc
+      version_file = create_file('version.rb', <<-EOS.strip_heredoc
                                  #main MyLibrary
                                  module MyLibrary
                                    VERSION = '0.0.0'
                                  end
                                  EOS
-                                )
+                               )
 
-      parser.parse( version_file )
+      parser.parse(version_file)
 
-      expect( parser.modules ).to eq( [ 'MyLibrary' ] )
+      expect(parser.modules).to eq([ 'MyLibrary' ])
     end
 
     it 'extracts nested modules as well' do
-      version_file = create_file( 'version.rb', <<-EOS.strip_heredoc
+      version_file = create_file('version.rb', <<-EOS.strip_heredoc
                                  #main MyLibrary
                                  module MyLibrary
                                    module MyClass
@@ -43,11 +43,22 @@ describe FeduxOrg::Stdlib::VersionManagement::RubygemVersionFileParser do
                                    end
                                  end
                                  EOS
-                                )
+                               )
+
+      parser.parse(version_file)
+
+      expect(parser.modules).to eq([ 'MyLibrary', 'MyClass' ])
+    end
 
-      parser.parse( version_file )
+    it 'fails if version cannot be extracted' do
+      version_file = create_file('version.rb', <<-EOS.strip_heredoc
+                                 #main MyLibrary
+                                 EOS
+                               )
 
-      expect( parser.modules ).to eq( [ 'MyLibrary', 'MyClass' ] )
+      expect {
+        parser.parse(version_file)
+      }.to raise_error VersionManagement::Exceptions::VersionFileInvalid
     end
   end
 end

data/spec/version_management/rubygem_version_file_spec.rb

@@ -1,116 +1,118 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'fedux_org/stdlib/version_management/rubygem_version_file'
-
-describe FeduxOrg::Stdlib::VersionManagement::RubygemVersionFile do
+require 'fedux_org_stdlib/version_management/rubygem_version_file'
 
+RSpec.describe FeduxOrgStdlib::VersionManagement::RubygemVersionFile do
   context '#to_s' do
-
     it 'outputs the content for version file' do
-      version = double( 'Version' )
-      expect(version).to receive( :to_s ).and_return( '0.0.0' )
+      version = double('Version')
+      expect(version).to receive(:to_s).and_return('0.0.0')
 
-      library = double( 'RubyLibrary' )
-      expect(library).to receive( :module_names ).and_return( [ 'MyLibrary' ] )
+      library = double('RubyLibrary')
+      expect(library).to receive(:module_names).and_return([ 'MyLibrary' ])
 
-      version_file = FeduxOrg::Stdlib::VersionManagement::RubygemVersionFile.new( version, library )
-      expect( version_file.to_s ).to eq(<<-EOS.strip_heredoc
-                                        #main MyLibrary
+      version_file = FeduxOrgStdlib::VersionManagement::RubygemVersionFile.new(version, library)
+      expect(version_file.to_s).to eq(<<-EOS.strip_heredoc
+                                        # encoding: utf-8
+                                        # MyLibrary
                                         module MyLibrary
                                           VERSION = '0.0.0'
                                         end
                                         EOS
-                                       )
+                                     )
     end
 
     it 'outputs the content for version file for a more deeply nested module' do
-      version = double( 'Version' )
-      expect(version).to receive( :to_s ).and_return( '0.0.0' )
+      version = double('Version')
+      expect(version).to receive(:to_s).and_return('0.0.0')
 
-      library = double( 'RubyLibrary' )
-      expect(library).to receive( :module_names ).and_return( [ 'MyLibrary', 'MyClass' ] )
+      library = double('RubyLibrary')
+      expect(library).to receive(:module_names).and_return([ 'MyLibrary', 'MyClass' ])
 
-      version_file = FeduxOrg::Stdlib::VersionManagement::RubygemVersionFile.new( version, library )
-      expect( version_file.to_s ).to eq(<<-EOS.strip_heredoc
-                                        #main MyLibrary
+      version_file = FeduxOrgStdlib::VersionManagement::RubygemVersionFile.new(version, library)
+      expect(version_file.to_s).to eq(<<-EOS.strip_heredoc
+                                        # encoding: utf-8
+                                        # MyLibrary
                                         module MyLibrary
                                           module MyClass
                                             VERSION = '0.0.0'
                                           end
                                         end
                                         EOS
-                                       )
+                                     )
     end
   end
 
   context '#write' do
     it 'writes the generated version file to disk' do
-      version = double( 'Version' )
-      expect(version).to receive( :to_s ).and_return( '0.0.0' )
+      version = double('Version')
+      expect(version).to receive(:to_s).and_return('0.0.0')
 
-      library = double( 'RubyLibrary' )
-      expect(library).to receive( :module_names ).and_return( [ 'MyLibrary', 'MyClass' ] )
-      version_file = FeduxOrg::Stdlib::VersionManagement::RubygemVersionFile.new( version, library )
+      library = double('RubyLibrary')
+      expect(library).to receive(:module_names).and_return([ 'MyLibrary', 'MyClass' ])
+      version_file = FeduxOrgStdlib::VersionManagement::RubygemVersionFile.new(version, library)
 
       switch_to_working_directory do
-        version_file.write( 'version.rb' )
-        expect( File ).to be_exists( 'version.rb' )
+        version_file.write('version.rb')
+        expect(File).to be_exists('version.rb')
       end
     end
 
     context '#read' do
       it 'reads a version file and handover parsing to parser' do
-        version = double( 'Version' )
-        library = double( 'Library' )
+        version = double('Version')
+        library = double('Library')
 
-        version_builder = double( 'VersionBuilder' )
-        expect( version_builder ).to receive( :build_from ).with( '0.0.0' ).and_return( version ) 
+        version_builder = double('VersionBuilder')
+        expect(version_builder).to receive(:build_from).with('0.0.0').and_return(version) 
 
-        library_builder = double( 'LibraryBuilder' )
-        expect( library_builder ).to receive( :build_from ).with( [ 'MyModule' ] ).and_return( library ) 
+        library_builder = double('LibraryBuilder')
+        expect(library_builder).to receive(:build_from).with([ 'MyModule' ]).and_return(library) 
 
-        parser = double( 'Parser' )
-        expect( parser ).to receive( :parse )
-        expect( parser ).to receive( :version ).and_return( '0.0.0' )
-        expect( parser ).to receive( :modules ).and_return( [ 'MyModule' ] )
+        parser = double('Parser')
+        expect(parser).to receive(:parse)
+        expect(parser).to receive(:version).and_return('0.0.0')
+        expect(parser).to receive(:modules).and_return([ 'MyModule' ])
 
-        version_file = create_file( 'version.rb', <<-EOS.strip_heredoc
-                                 #main MyLibrary
+        version_file = create_file('version.rb', <<-EOS.strip_heredoc
+                                 # encoding: utf-8
+                                 # MyLibrary
                                  module MyLibrary
                                    VERSION = '0.0.0'
                                  end
                                  EOS
-                                )
+                              )
 
-        result = FeduxOrg::Stdlib::VersionManagement::RubygemVersionFile.read( version_file, parser, version_builder, library_builder )
+        result = FeduxOrgStdlib::VersionManagement::RubygemVersionFile.read(version_file, parser, version_builder, library_builder)
 
-        expect( result ).to be_kind_of( FeduxOrg::Stdlib::VersionManagement::RubygemVersionFile )
+        expect(result).to be_kind_of(FeduxOrgStdlib::VersionManagement::RubygemVersionFile)
       end
     end
 
     context '#version' do
       it "returns the version for the file" do
-        version = double( 'Version' )
-        expect(version).to receive( :to_s ).and_return( '0.0.0' )
+        version = double('Version')
+        expect(version).to receive(:to_s).and_return('0.0.0')
 
-        library = double( 'RubyLibrary' )
+        library = double('RubyLibrary')
 
-        version_file = FeduxOrg::Stdlib::VersionManagement::RubygemVersionFile.new( version, library )
-        expect( version_file.version ).to eq('0.0.0' )
+        version_file = FeduxOrgStdlib::VersionManagement::RubygemVersionFile.new(version, library)
+        expect(version_file.version).to eq('0.0.0')
       end
     end
 
     context '#bump' do
       it "bumps versions" do
-        version = double( 'Version' )
-        expect(version).to receive( :bump ).with( :major )
-        expect(version).to receive( :to_s ).and_return( '1.0.0' )
+        version = double('Version')
+        expect(version).to receive(:bump).with(:major)
+        expect(version).to receive(:to_s).and_return('1.0.0')
 
-        library = double( 'RubyLibrary' )
+        library = double('RubyLibrary')
 
-        version_file = FeduxOrg::Stdlib::VersionManagement::RubygemVersionFile.new( version, library )
-        version_file.bump( :major )
+        version_file = FeduxOrgStdlib::VersionManagement::RubygemVersionFile.new(version, library)
+        version_file.bump(:major)
 
-        expect( version_file.version ).to eq('1.0.0' )
+        expect(version_file.version).to eq('1.0.0')
       end
     end
   end