RubyGems - rack-blogengine - Versions diffs - 0.2.4 → 0.2.5 - Mend

rack-blogengine 0.2.4 → 0.2.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

checksums.yaml +4 -4
data/.travis.yml +2 -2
data/Gemfile +1 -1
data/README.md +1 -1
data/Rakefile +1 -22
data/assets/date_test.content +6 -0
data/assets/operator.content +4 -0
data/assets/pygment.content +4 -0
data/features/support/env.rb +2 -2
data/lib/rack/blogengine/application.rb +8 -3
data/lib/rack/blogengine/application_router.rb +16 -12
data/lib/rack/blogengine/command_line_interface.rb +39 -36
data/lib/rack/blogengine/document_parser.rb +32 -27
data/lib/rack/blogengine/operator.rb +2 -2
data/lib/rack/blogengine/version.rb +1 -1
data/rack-blogengine.gemspec +1 -0
data/spec/spec_helper.rb +1 -1
data/tasks/default.rake +5 -0
data/tasks/floodtest.rake +33 -0
data/tasks/test.rake +19 -0
data/test/rack/blogengine/application_router_test.rb +9 -6
data/test/rack/blogengine/application_test.rb +37 -0
data/test/rack/blogengine/command_line_interface_test.rb +7 -40
data/test/rack/blogengine/document_parser_test.rb +37 -122
data/test/test_helper.rb +4 -1
metadata +42 -29
data/test/rack/blogengine/document_test.rb +0 -48

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f534d53e3f8a5de64f425c908071cc8065f4a7b3
-  data.tar.gz: 9c43691dc1d6f4afbe44f92712e2cbd3ceb77fcb
+  metadata.gz: 8a9967ebc1f5812da39b323ccbfab72c1a0ad7d3
+  data.tar.gz: 3df6682117a5998123b822ad64154ac4f397beb4
 SHA512:
-  metadata.gz: d713e85703385cc5302c553e39c03c03c3f9ee2210d680e78c045597a7e6f26d734148dcb317c8670dcef21daf92a6dd04b100d507b7db7691d30bb68b5bd5f1
-  data.tar.gz: 368350df768dd879a29436e1847f7bacb900b9071385d4512575796ec663246bcade7a112d09fd6ed83e14942980638f8b83430c6c7400f9545f72f0f10da150
+  metadata.gz: 9b52f8b93f472e3c98589d7be691dd1959ec2fdc7e0902702196cd5d3ec2907a7779c48422c2c9c521acf2d791db153a1401baa91bc517e48067c0e8e6c69192
+  data.tar.gz: c37ea97848979aefc91bdcc0f029cb9536a3010bb21b762c9faaf5737db462b877b2dd9fcf40c8f83925fcae048e3cb9a391a1efd15d6c1001786e3e17212f96

data/.travis.yml CHANGED Viewed

@@ -2,9 +2,9 @@ language: ruby
 cache: bundler
 rvm:
-  - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.1.1
   - ruby-head
   - jruby
   - rbx
@@ -15,4 +15,4 @@ matrix:
     - rvm: jruby
     - rvm: ruby-head
-script:  "env COVERAGE=true bundle exec rake"
+script:  "env COVERAGE=true bundle exec rake"

data/Gemfile CHANGED Viewed

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
-gem "rubysl-test-unit", :platform => :rbx
+# gem "rubysl-test-unit", :platform => :rbx
 # Specify your gem's dependencies in rack-blogengine.gemspec
 gemspec

data/README.md CHANGED Viewed

@@ -12,9 +12,9 @@ Rack Middleware to serve a simple blog
 ## Supported Ruby Versions & Platforms
 - rbx   2.2.5
-- ruby  1.9.3
 - ruby  2.0.0
 - ruby  2.1.0
+- ruby  2.1.1
 - jruby 1.7.9
 ## Installation

data/Rakefile CHANGED Viewed

@@ -2,27 +2,6 @@ require "bundler/gem_tasks"
 require 'rake/testtask'
 require 'cucumber/rake/task'
+Dir.glob('tasks/*.rake').each { |r| import r }
-namespace :test do
-  Rake::TestTask.new(:unit) do |t|
-    t.libs << "test" << "bin" << "ext"
-    t.test_files = FileList['test/**/*_test.rb']
-    t.verbose = true
-  end
-  Rake::TestTask.new(:spec) do |t|
-    t.libs << "spec" << "bin" << "ext"
-    t.test_files = FileList['spec/**/*_spec.rb']
-    t.verbose = true
-  end
-  Cucumber::Rake::Task.new(:feature) do |t|
-    t.cucumber_opts = "features --format pretty"
-  end
-end
-task :default do
-  Rake::Task['test:unit'].invoke
-  # Rake::Task['test:spec'].invoke
-  Rake::Task['test:feature'].invoke
-end

data/assets/date_test.content ADDED Viewed

@@ -0,0 +1,6 @@
+[path]:[/path]
+[title]:INDEX[/title]
+[date]:2012,01,01[/date]
+[content]:
+<h2>This is 2012</h2>
+[/content]

data/assets/operator.content ADDED Viewed

@@ -0,0 +1,4 @@
+[path]:[/path]
+[title]:operator[/title]
+[date]:2013,01,01[/date]
+[content]:{% test_operator %}[/content]

data/assets/pygment.content ADDED Viewed

@@ -0,0 +1,4 @@
+[path]:[/path]
+[title]:pygment[/title]
+[date]:2013,01,01[/date]
+[content]:<pre class="brush:ruby">def TestMethod</pre>[/content]

data/features/support/env.rb CHANGED Viewed

@@ -14,7 +14,7 @@ SimpleCov.start do
   add_filter '/features/'
   add_filter '/doc/'
   add_filter '/assets/'
-end if ENV["COVERAGE"]
+end if ENV['COVERAGE']
 require 'capybara/cucumber'
 require 'rack/blogengine'
@@ -22,4 +22,4 @@ require 'rack/blogengine'
 Rack::Blogengine.documents = [{ html: '<!DOCTYPE html><body><h2>index</h2></body></html>',
                                 path: '/' }]
-Capybara.app = Rack::Blogengine::Application
+Capybara.app = Rack::Blogengine::Application.new

data/lib/rack/blogengine/application.rb CHANGED Viewed

@@ -7,14 +7,19 @@ module Rack
     # @author [benny]
     #
     class Application
+      # def initialize(app)
+        # @app = app
+      # end
       # Call Method for run this method as Rack Middleware.
       # @param env Environment contains information such as path, headers etc...
       # @return [Array] response Array
-      def self.call(env)
+      def call(env)
+        request = Rack::Request.new(env)
         # Router for map docs to routes
-        route = ApplicationRouter.map_route(env, Rack::Blogengine.documents)
+        route = ApplicationRouter.map_route(request, Rack::Blogengine.documents)
-        route['response']
+        route['response'].finish
       end
     end
   end

data/lib/rack/blogengine/application_router.rb CHANGED Viewed

@@ -11,17 +11,18 @@ module Rack
       # @param documents Documents which will be looked at
       # @return [Hash] route Hash {:path => "/foo", :response => [Array]}
       class << self
-        def map_route(env, documents)
-          success_status = 200
+        def map_route(request, documents)
           header = { 'Content-Type' => 'text/html; charset=UTF-8' }
-          path = env['PATH_INFO']
           # Iterate through available docs, if nothing matched return nil
           documents.each do |doc|
-            if doc[:path] == path
+            if doc[:path] == request.path
+              response = Rack::Response.new(doc[:html], 200, header)
               route_response = {
-                'path' => path,
-                'response' => [success_status, header, [doc[:html]]]
+                'path' => request.path,
+                'response' => response
+                # 'response' => [200, header, [doc[:html]]]
               }
               return route_response
@@ -29,15 +30,18 @@ module Rack
           end
           # if no document matches -> return error page
-          return errorpage(env, documents)
+          errorpage(request, documents)
         end
-        def errorpage(env, documents)
-          { 'path' => env['PATH_INFO'],
-            'response' =>
-            [404, { 'Content-Type' => 'text/html; charset=UTF-8' }, ['Page not found']]
-          }
+        def errorpage(request, documents)
+          header = { 'Content-Type' => 'text/html; charset=UTF-8' }
+          response = Rack::Response.new('Page not found', 404, header)
+          { 'path' => request.path, 'response' => response }
         end
+      private :errorpage
       end
     end
   end

data/lib/rack/blogengine/command_line_interface.rb CHANGED Viewed

@@ -11,7 +11,7 @@ module Rack
     class CommandLineInterface
       def method_missing(name, *args)
         puts "Command #{name} not available"
-        print 'Available Commands are: \n\n'
+        print "Available Commands are: \n\n"
         self.class.instance_methods(false).each do |method|
           print "\t #{method}\n" unless method == :method_missing # || method == :setup || method == :getConfig
         end
@@ -35,38 +35,6 @@ module Rack
         end
       end
-      #
-      # Build rack app via Rack::Builder
-      # @param  target String The Targetfolder where all relevant files are located
-      # @param  config [type] Config via get_config -> parses in config.yml
-      #
-      # @return [type] [description]
-      def build_rack_app(target, config)
-        app = Rack::Builder.new do
-          map '/assets' do
-            run Rack::Directory.new("#{target}/assets")
-          end
-          # use Rack::CommonLogger
-          # use Rack::ShowExceptions
-          # use Rack::Lint
-          if config['Usage'] == 'yes'
-            use Rack::Auth::Basic, 'Protected Area' do |username, password|
-              username == config['Username'] && password == config['Password']
-            end
-          end
-          # Parse in all Documents in cli.run(target)
-          # -> $documents are parsed in only once and then cached via a global variable
-          # Todo Cache without global variable?
-          # Global Variable replaced with module instance variable
-          Rack::Blogengine.documents = DocumentParser.parse_in_documents(target)
-          run Application
-        end
-      end
       # Command to generate the folder skeleton
       # @param [String] folder
       def generate(folder)
@@ -105,11 +73,37 @@ module Rack
       # Display Version
       # return [String] VERSION
-      def version?
+      def version
         puts "\n\tVERSION: #{Rack::Blogengine::VERSION}\n\tRack::Blogengine releases are all pre-relases, first production release will be VERSION 1.0.0\n\n"
       end
-      private
+      #
+      # Build rack app via Rack::Builder
+      # @param  target String The Targetfolder where all relevant files are located
+      # @param  config [type] Config via get_config -> parses in config.yml
+      #
+      # @return [type] [description]
+      def build_rack_app(target, config)
+        Rack::Builder.new do
+          map '/assets' do
+            run Rack::Directory.new("#{target}/assets")
+          end
+          if config['Usage'] == 'yes'
+            use Rack::Auth::Basic, 'Protected Area' do |username, password|
+              username == config['Username'] && password == config['Password']
+            end
+          end
+          # Parse in all Documents in cli.run(target)
+          # -> $documents are parsed in only once and then cached via a global variable
+          # Todo Cache without global variable?
+          # Global Variable replaced with module instance variable
+          Rack::Blogengine.documents = DocumentParser.parse_in_documents(target)
+          run Application.new
+        end
+      end
       # Helper method for generate to set up all essential files
       # param [String] name
@@ -137,8 +131,17 @@ module Rack
         pygments_style = config_yaml['Pygments']['style']
         pygments_seperator = config_yaml['Pygments']['seperator']
-        Rack::Blogengine.config = { 'Port' => port, 'Server' => server, 'Username' => username, 'Password' => password, 'Usage' => usage, 'pygments_style' => pygments_style, 'pygments_seperator' => pygments_seperator}
+        Rack::Blogengine.config = { 'Port' => port,
+                                    'Server' => server,
+                                    'Username' => username,
+                                    'Password' => password,
+                                    'Usage' => usage,
+                                    'pygments_style' => pygments_style,
+                                    'pygments_seperator' => pygments_seperator }
       end
+    private :get_config, :setup, :build_rack_app
     end
   end
 end

data/lib/rack/blogengine/document_parser.rb CHANGED Viewed

@@ -10,7 +10,11 @@ module Rack
     #
     module DocumentParser
       class << self
-        attr_accessor :title, :content, :date, :target
+        private
+        attr_accessor :path, :title, :content, :date, :html, :layout
+        public
+        attr_accessor :target
       end
       # Parse in .content Documents.
@@ -20,32 +24,32 @@ module Rack
         @target = target
         documents = []
-        layout_file = ::File.open("#{@target}/assets/layout/layout.html", 'r')
-        @layout = layout_file.read
+        layout_file = ::File.open("#{target}/assets/layout/layout.html", 'r')
+        layout = layout_file.read
         Dir.foreach("#{target}/") do |item|
           extension = item.split('.')[1]
           next if item == '.' || item == '..' || extension != 'content'
           get_file_contents(item)
-          @html = fill_file_contents(@layout, @title, @content, @date)
+          html = fill_file_contents(layout, title, content, date)
           @document = Document.new
-          @document.path = @path
-          @document.html = @html
-          @document.title = @title
-          @document.date = @date
+          @document.path = path
+          @document.html = html
+          @document.title = title
+          @document.date = date
           documents << @document
         end
-        generate_highlight_css(@target)
+        generate_highlight_css(target)
         sort(documents)
         # Has to exec operator after all docs were read,
         # so documents are available for operators (list all docs, etc...)
         documents.each do |document|
-          document.exec_content_operator(documents, @target)
+          document.exec_content_operator(documents, target)
         end
         documents.map do |document|
@@ -56,7 +60,7 @@ module Rack
       # Get File Contents (path, title, content)
       # @param [String] file
       def self.get_file_contents(file)
-        content_file = ::File.open("#{@target}/#{file}")
+        content_file = ::File.open("#{target}/#{file}")
         content = content_file.read
         contentarray = get_content_array(content)
@@ -65,27 +69,24 @@ module Rack
           if contentblock.include? '[path]:'
             contentblock['[path]:'] = ''
             @path = "/#{contentblock}"
-          end
-          if contentblock.include? '[title]:'
+          elsif contentblock.include? '[title]:'
             contentblock['[title]:'] = ''
             if contentblock.strip.empty?
-              raise "Title in #{file} is empty"
+              fail "Title in #{file} is empty"
             else
               @title = contentblock.strip
             end
-          end
-          if contentblock.include? '[content]:'
+          elsif contentblock.include? '[content]:'
             contentblock['[content]:'] = ''
             if contentblock.strip.empty?
-              raise "Content in #{file} is empty"
+              fail "Content in #{file} is empty"
             else
               @content = contentblock.strip
             end
-          end
-          if contentblock.include? '[date]:'
+          elsif contentblock.include? '[date]:'
             contentblock['[date]:'] = ''
             if /\d/.match( contentblock )
               datearray = contentblock.split(',')
@@ -95,7 +96,7 @@ module Rack
               @date = Date.new(datearray[0], datearray[1], datearray[2])
             else
-              raise "Invalid Date in #{file}\n [date]:#{contentblock}[/date]"
+              fail "Invalid Date in #{file}\n [date]:#{contentblock}[/date]"
             end
           end
         end
@@ -119,12 +120,12 @@ module Rack
         highlight_code = { text: html.css(seperator).text, brush: brush }
       end
-      def self.highlight(code, language, target)
-        if language
-          Pygments.highlight(code, :lexer => language.to_sym)
-        else
-          code
-        end
+      def self.highlight(code, language)
+        # if language
+        Pygments.highlight(code, :lexer => language.to_sym)
+        # else
+          # code
+        # end
       end
       def self.generate_highlight_css(target)
@@ -157,7 +158,7 @@ module Rack
         html.css(seperator).map do |html|
           highlight_code = get_highlight_code(html.to_s, seperator)
-          highlighted = highlight(highlight_code[:text], highlight_code[:brush], @target)
+          highlighted = highlight(highlight_code[:text], highlight_code[:brush])
           html.replace(highlighted)
         end
@@ -176,6 +177,10 @@ module Rack
         documents
       end
+      class << self
+        private :sort, :fill_file_contents, :generate_highlight_css, :highlight, :get_highlight_code, :get_content_array, :get_file_contents
+      end
     end
   end
 end

data/lib/rack/blogengine/operator.rb CHANGED Viewed

@@ -6,8 +6,8 @@
 #
 class Operator
   def initialize(target)
-  	target = Pathname.new("#{target}").realpath.to_s
-    Dir["#{target}/operator/*.rb"].each {|file| require file }
+    target = Pathname.new("#{target}").realpath.to_s
+    Dir["#{target}/operator/*.rb"].each { |file| require file }
     extend UserOperator # load user operators
   end

data/lib/rack/blogengine/version.rb CHANGED Viewed

@@ -6,6 +6,6 @@ module Rack
   # @author [benny]
   #
   module Blogengine
-    VERSION = '0.2.4'.freeze
+    VERSION = '0.2.5'.freeze
   end
 end

data/rack-blogengine.gemspec CHANGED Viewed

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "cucumber"
   spec.add_development_dependency "capybara"
   spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "rack-test"
   spec.add_runtime_dependency "rack"
   spec.add_runtime_dependency "pygments.rb"

data/spec/spec_helper.rb CHANGED Viewed

@@ -37,7 +37,7 @@ SimpleCov.start do
   add_filter '/features/'
   add_filter '/doc/'
   add_filter '/assets/'
-end if ENV["COVERAGE"]
+end if ENV['COVERAGE']
 # Minitest
 require 'minitest/autorun'

data/tasks/default.rake ADDED Viewed

@@ -0,0 +1,5 @@
+task :default do
+  Rake::Task['test:unit'].invoke
+  # Rake::Task['test:spec'].invoke
+  Rake::Task['test:feature'].invoke
+end

data/tasks/floodtest.rake ADDED Viewed

@@ -0,0 +1,33 @@
+test_runs = if ENV['TESTS']
+              Interger(ENV['TESTS'])
+            else
+              30
+            end
+namespace :floodtest do
+  task :unit do
+    desc 'Run Unit floodtest (default 30 tests, configurable via ENV["TESTS"])'
+    1.upto(test_runs) do |i|
+      puts "Running test #{i} of #{test_runs}"
+      exit(-1) if !system('bundle exec rake test:unit')
+    end
+  end
+  task :spec do
+    desc 'Run Spec floodtest (default 30 tests, configurable via ENV["TESTS"])'
+    1.upto(test_runs) do |i|
+      puts "Running test #{i} of #{test_runs}"
+      exit(-1) if !system('bundle exec rake test:spec ')
+    end
+  end
+  task :feature do
+    desc 'Run Feature floodtest (default 30 tests, configurable via ENV["TESTS"])'
+    1.upto(test_runs) do |i|
+      puts "Running test #{i} of #{test_runs}"
+      exit(-1) if !system('bundle exec rake test:feature')
+     end
+   end
+end

data/tasks/test.rake ADDED Viewed

@@ -0,0 +1,19 @@
+namespace :test do
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << "test" << "bin" << "ext" << "controllers" << "helpers" << "models"
+    t.test_files = FileList['test/**/*_test.rb']
+    t.verbose = true
+  end
+  Rake::TestTask.new(:spec) do |t|
+    t.libs << "spec" << "bin" << "ext" << "controllers" << "helpers" << "models"
+    t.test_files = FileList['spec/**/*_spec.rb']
+    t.verbose = true
+  end
+  Cucumber::Rake::Task.new(:feature) do |t|
+    t.cucumber_opts = "features --format pretty"
+  end
+end

data/test/rack/blogengine/application_router_test.rb CHANGED Viewed

@@ -12,10 +12,13 @@ class ApplicationRouterTest < MiniTest::Unit::TestCase
                    path: '/' }]
     env_fail = { 'PATH_INFO' => '/fail' }
+    request_fail = Rack::Request.new(env_fail)
     env_success = { 'PATH_INFO' => '/' }
+    request_success = Rack::Request.new(env_success)
-    @route_success = Rack::Blogengine::ApplicationRouter.map_route(env_success, documents)
-    @route_fail = Rack::Blogengine::ApplicationRouter.map_route(env_fail, documents)
+    @route_success = Rack::Blogengine::ApplicationRouter.map_route(request_success, documents)
+    @route_fail = Rack::Blogengine::ApplicationRouter.map_route(request_fail, documents)
   end
   def test_map_route_general
@@ -29,16 +32,16 @@ class ApplicationRouterTest < MiniTest::Unit::TestCase
     assert_instance_of(String, @route_success['path'], 'Path should be a string')
     # Check response
-    assert_instance_of(Array, @route_success['response'], 'Response should be an Array')
-    assert_instance_of(Fixnum, @route_success['response'][0], 'Status should be a Fixnum')
+    assert_instance_of(Rack::Response, @route_success['response'], 'Response should be an Array')
+    assert_instance_of(Fixnum, @route_success['response'].status, 'Status should be a Fixnum')
   end
   def test_map_route_on_success
-    assert_equal(200, @route_success['response'][0], 'Status should be 200')
+    assert_equal(200, @route_success['response'].status, 'Status should be 200')
   end
   def test_map_route_on_fail
-    assert_equal(404, @route_fail['response'][0], 'Status should be 404')
+    assert_equal(404, @route_fail['response'].status, 'Status should be 404')
   end
   def teardown

data/test/rack/blogengine/application_test.rb ADDED Viewed

@@ -0,0 +1,37 @@
+require 'test_helper.rb'
+#
+# TestClass for ApplicationRouter
+#
+# @author [benny]
+#
+class ApplicationTest < MiniTest::Unit::TestCase
+  include Rack::Test::Methods
+  class MockApp
+    def call(env = nil)
+      [200, {}, ["hello"]]
+    end
+  end
+  def app
+  	Rack::Blogengine::Application.new
+  end
+  def setup
+  	@cli = Rack::Blogengine::CommandLineInterface.new
+    capture_stdout { @cli.generate(testpath) }
+    Rack::Blogengine.config = @cli.send(:get_config, testpath)
+    Rack::Blogengine.documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath)
+  end
+  def test_application_is_callable
+  	get '/'
+  	assert(last_response.body.include?('This is the Index Page'))
+  end
+  def teardown
+  	system("rm -rf #{testpath}")
+  end
+end

data/test/rack/blogengine/command_line_interface_test.rb CHANGED Viewed

@@ -14,7 +14,7 @@ class CommandLineInterfaceTest < MiniTest::Unit::TestCase
     assert(@cli.respond_to?(:method_missing), 'CLI should respond to :method_missing method')
     assert(@cli.respond_to?(:run), 'CLI should respond to :run method')
     assert(@cli.respond_to?(:generate), 'CLI should respond to :generate method')
-    assert(@cli.respond_to?(:version?), 'CLI should respond to :version? method')
+    assert(@cli.respond_to?(:version), 'CLI should respond to :version? method')
   end
   def test_methods_missing
@@ -23,13 +23,12 @@ class CommandLineInterfaceTest < MiniTest::Unit::TestCase
   end
   def test_version?
-    result = capture_stdout { @cli.send(:version?) }
+    result = capture_stdout { @cli.send(:version) }
     assert(result.include?('VERSION'), ':version? should output the current VERSION')
   end
   def test_generate
     capture_stdout { @cli.send(:generate, testpath) }
     assert(Dir.exist?(testpath), 'Test Directory should exist after generate method')
     assert(Dir.exist?("#{testpath}/assets"), 'assets Directory should exist after generate method')
     assert(Dir.exist?("#{testpath}/assets/layout"), 'assets/layout Directory should exist after generate method')
@@ -37,14 +36,12 @@ class CommandLineInterfaceTest < MiniTest::Unit::TestCase
     assert(Dir.exist?("#{testpath}/assets/js"), 'assets/js Directory should exist after generate method')
     assert(Dir.exist?("#{testpath}/assets/images"), 'assets/images Directory should exist after generate method')
     assert(Dir.exist?("#{testpath}/operator"), 'operator Directory should exist after generate method')
     assert(File.exist?("#{testpath}/operator/operator.rb"), 'operator.rb should exist after generate method')
     assert(File.exist?("#{testpath}/config.yml"), 'config.yml should exist after generate method')
     assert(File.exist?("#{testpath}/index.content"), 'index.content should exist after generate method')
     assert(File.exist?("#{testpath}/assets/layout/layout.html"), 'layout.html should exist after generate method')
     assert(File.exist?("#{testpath}/assets/style/style.css"), 'style.css should exist after generate method')
     assert(File.exist?("#{testpath}/assets/js/script.js"), 'script.js should exist after generate method')
     system("rm -rf #{testpath}")
   end
@@ -58,47 +55,17 @@ class CommandLineInterfaceTest < MiniTest::Unit::TestCase
     assert_equal('/not_a_directory is not a folder!', result, 'run method should output "Target is not a folder!" when folderstring is not a directory')
   end
-  # def test_run
-    # capture_stdout { @cli.send(:generate, testpath) }
-    # server_thread = Thread.new do
-      # capture_stdout { @cli.send(:run, testpath) }
-    # end
-    # sleep(2) # wait a sec for the server to be booted
-    # Thread.list.each {|t| t.exit }
-    # Thread.list.each {|t| p t }
-    # system("rm -rf #{testpath}")
-  # end
   def test_build_rack_app
-    capture_stdout { @cli.send(:generate, testpath) }
+    capture_stdout { @cli.generate(testpath) }
     config = @cli.send(:get_config, testpath)
     config['Usage'] = 'yes'
-    config["Username"] = 'testUser'
-    config['Password'] = 'test'
+    config['Username'] = 'Benny'
+    config['Password'] = 'Bensn'
     app = @cli.send(:build_rack_app, testpath, config)
-    assert_instance_of(Rack::Builder, app, 'App should be of class Rack::Builder')
-    # @todo : add better tests
+    assert_instance_of(Rack::Builder, app, 'Rack app should be instance of Rack::Builder')
     system("rm -rf #{testpath}")
   end
-  def test_get_config
-    capture_stdout { @cli.send(:generate, testpath) }
-    config = @cli.send(:get_config, testpath)
-    assert_equal(3000, config['Port'], 'Default Port should be 3000')
-    assert_equal('webrick', config['Server'], 'Default Server should be webrick')
-    assert_equal('', config['Username'], 'Default Username should not be set')
-    assert_equal('', config['Password'], 'Default Password should not be set')
-    assert_equal('no', config['Usage'], 'Default HTTP Auth Usage should be no')
-    system("rm -rf #{testpath}")
-  end
 end

data/test/rack/blogengine/document_parser_test.rb CHANGED Viewed

@@ -6,147 +6,62 @@ require 'test_helper'
 # @author [benny]
 #
 class DocumentParserTest < MiniTest::Unit::TestCase
-  # parallelize_me!
   def setup
-    cli = Rack::Blogengine::CommandLineInterface.new
-    capture_stdout { cli.generate(testpath) }
-    cli.send(:get_config, testpath)
+    @cli = Rack::Blogengine::CommandLineInterface.new
+    capture_stdout { @cli.generate(testpath) }
+    @cli.send(:get_config, testpath)
   end
-  # Test DocumentParser.parse_in_documents(path)
   def test_parse_in_documents
-    @documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath)
+    documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath)
-    @documents.each do |document|
+    documents.each do |document|
       # Check Hash keys
-      assert(document.key?(:html), 'Documents should contain a path')
-      assert(document.key?(:path), 'Documents should contain a response')
+      assert(document.key?(:html), 'Documents should contain content')
+      assert(document.key?(:path), 'Documents should contain a path')
     end
   end
-  # Test DocumentParser.fill_file_contents(layout, title, content, date)
-  def test_fill_file_contents
-    layout_file = ::File.open("#{testpath}/assets/layout/layout.html", 'r')
-    layout = layout_file.read
-    title = 'testtitle'
-    content = 'testcontent'
-    date = Date.new
-    html = Rack::Blogengine::DocumentParser.fill_file_contents(layout, title, content, date)
-    assert(html.include?(title), 'Parsed and filled in HTML should contain Title')
-    assert(html.include?(content), 'Parsed and filled in HTML should contain Content')
-    assert(html.include?(date.strftime('%d.%m.%Y')), 'Parsed and filled in HTML should contain Date')
-  end
-  def test_fill_file_contents_with_pygments
-    layout_file = ::File.open("#{testpath}/assets/layout/layout.html", 'r')
-    layout = layout_file.read
-    title = 'testtitle'
-    content = '<pre class="brush:ruby">def TestMethod</pre>'
-    date = Date.new
-    html = Rack::Blogengine::DocumentParser.fill_file_contents(layout, title, content, date)
-    assert(html.include?(title), 'Parsed and filled in HTML should contain Title')
-    assert(html.include?("highlight"), 'Parsed and filled in HTML with pygment handling should contain .highlight class')
-    assert(html.include?(date.strftime('%d.%m.%Y')), 'Parsed and filled in HTML should contain Date')
-  end
-  # Test DocumentParser.get_file_contents('file.content')
-  def test_get_file_contents
-    Rack::Blogengine::DocumentParser.title = ''
-    Rack::Blogengine::DocumentParser.content = ''
-    Rack::Blogengine::DocumentParser.date = ''
-    Rack::Blogengine::DocumentParser.target = "#{Rack::Blogengine.root}/assets"
-    Rack::Blogengine::DocumentParser.get_file_contents('index.content')
-    assert_equal('INDEX', Rack::Blogengine::DocumentParser.title, 'Parsed in Title should eql Title in test .content file')
-    assert_equal('<h2>This is the Index Page</h2>', Rack::Blogengine::DocumentParser.content, 'Parsed in Content should eql Content in test .content file')
-    assert_instance_of(Date, Rack::Blogengine::DocumentParser.date, 'Parsed in Date should be of Class Date')
+  def test_invalid_date
+    system("rm #{testpath}/index.content")
+    capture_stdout { @cli.send(:setup, "date_error.content", "#{testpath}", true) }
+    assert_raises(RuntimeError) { documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath) }
   end
-  def test_get_file_contents_invalid_date
-    Rack::Blogengine::DocumentParser.target = "#{Rack::Blogengine.root}/assets"
-    assert_raises(RuntimeError) { Rack::Blogengine::DocumentParser.get_file_contents('date_error.content') }
+  def test_invalid_content
+    system("rm #{testpath}/index.content")
+    capture_stdout { @cli.send(:setup, "content_error.content", "#{testpath}", true) }
+    assert_raises(RuntimeError) { documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath) }
   end
-  def test_get_file_contents_invalid_content
-    Rack::Blogengine::DocumentParser.target = "#{Rack::Blogengine.root}/assets"
-    assert_raises(RuntimeError) { Rack::Blogengine::DocumentParser.get_file_contents('content_error.content') }
+  def test_invalid_title
+    system("rm #{testpath}/index.content")
+    capture_stdout { @cli.send(:setup, "title_error.content", "#{testpath}", true) }
+    assert_raises(RuntimeError) { documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath) }
   end
-  def test_get_file_contents_invalid_title
-    Rack::Blogengine::DocumentParser.target = "#{Rack::Blogengine.root}/assets"
-    assert_raises(RuntimeError) { Rack::Blogengine::DocumentParser.get_file_contents('title_error.content') }
-  end
-  # Test DocumentParser.get_content_array(contentstring)
-  # Should split up the content for each content section (Path, Title, Date, Content)
-  def test_get_content_array
-    content = '[path]:[/path]
-               [title]:INDEX[/title]
-               [date]:2013,01,01[/date]
-               [content]:
-               <h2>This is the Index Page</h2>
-               [/content]'
-    contentarray = Rack::Blogengine::DocumentParser.get_content_array(content)
-    assert_equal(4, contentarray.length, 'The content Array should contain 4 members (Path, Title, Date, Content)')
-    assert(contentarray[0].include?('path'), 'First Entry should contain the path')
-    assert(contentarray[1].include?('title'), 'Second Entry should contain the title')
-    assert(contentarray[2].include?('date'), 'Third Entry should contain the date')
-    assert(contentarray[3].include?('content'), 'Fourth Entry should contain the content')
-  end
-  # Test DocumentParser.sort(documents)
-  def test_sort
-    documents = []
-    document1 = Rack::Blogengine::Document.new
-    document1.date = Date.new(2013, 12, 12)
-    document2 = Rack::Blogengine::Document.new
-    document2.date = Date.new(2012, 12, 12)
-    documents << document1 << document2
-    documents = Rack::Blogengine::DocumentParser.sort(documents)
-    assert_equal(Date.new(2012, 12, 12), documents[0].date, 'Documents should be sorted by date (earlier first)')
-  end
-  def test_highlight
-    content = "def TestMethod"
-    highlighted = Rack::Blogengine::DocumentParser.highlight(content, 'ruby', testpath)
-    assert_match(/.highlight/, highlighted, "Highlighted html should contain a element with class highlight")
-  end
-  def test_highlight_fail
-    content = "def TestMethod"
-    highlighted = Rack::Blogengine::DocumentParser.highlight(content, nil, testpath)
-    assert_equal(content, highlighted, "If Language is not defined Content should be returned unmodified")
+  def test_documents_with_pygments
+    capture_stdout { @cli.send(:setup, "pygment.content", "#{testpath}", true) }
+    system("rm #{testpath}/index.content")
+    documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath)
+    documents.each do |document|
+      assert(document[:html].include?('class="highlight"'), 'Highlighted code should be wrapped in a div.highlight')
+    end
   end
-  def test_generate_highlight_css
-    Rack::Blogengine::DocumentParser.generate_highlight_css(testpath)
-    # css = Pygments.css(Rack::Blogengine.config["pygments_style"])
-    highlightcss = ::File.read("#{testpath}/assets/style/highlight.css")
-    # assert_equal(css, highlightcss, "Highlight Css file should be automatically filled in")
-    refute_empty(highlightcss, "Highlight Css file should be automatically filled in")
+  def test_documents_with_operator
+    capture_stdout { @cli.send(:setup, "operator.content", "#{testpath}", true) }
+    system("rm #{testpath}/index.content")
+    documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath)
+    documents.each do |document|
+      assert(document[:html].include?('test'), 'Test Operator should return test')
+    end
   end
-  def test_get_highlight_code
-    content = "<html><head><title>Test</title></head><body><pre class='brush:ruby'>def TestMethod</pre></body></html>"
-    seperator = Rack::Blogengine.config["pygments_seperator"]
-    highlight_code = Rack::Blogengine::DocumentParser.get_highlight_code(content, seperator)
-    assert_equal('def TestMethod', highlight_code[:text], "Code between #{seperator} should be returned")
-    assert_equal('ruby', highlight_code[:brush], "Brush should be recognised by the class attribute")
+  def test_document_sort
+    capture_stdout { @cli.send(:setup, "date_test.content", "#{testpath}", true) }
+    documents = Rack::Blogengine::DocumentParser.parse_in_documents(testpath)
+    assert(documents[0][:html].include?('This is 2012'), 'The Document with lower date should be first')
   end
   def teardown

data/test/test_helper.rb CHANGED Viewed

@@ -14,7 +14,7 @@ SimpleCov.start do
   add_filter '/features/'
   add_filter '/doc/'
   add_filter '/assets/'
-end if ENV["COVERAGE"]
+end if ENV['COVERAGE']
 # Previous content of test helper now starts here
@@ -23,6 +23,9 @@ require 'minitest/autorun'
 require 'minitest/mock'
 require 'minitest/pride' # for colored output
+# Rack Test Methods
+require 'rack/test'
 # TestUnit -> MiniTest (TestUnit is only compatibility Layer)
 # require 'test/unit'

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-blogengine
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Benny1992
@@ -9,77 +9,85 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-02-20 00:00:00 Z
+date: 2014-03-04 00:00:00 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: "1.3"
-  type: :development
+  name: bundler
+  prerelease: false
   version_requirements: *id001
+  type: :development
 - !ruby/object:Gem::Dependency
-  name: rake
-  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement
     requirements:
     - &id003
       - ">="
       - !ruby/object:Gem::Version
         version: "0"
-  type: :development
+  name: rake
+  prerelease: false
   version_requirements: *id002
+  type: :development
 - !ruby/object:Gem::Dependency
-  name: cucumber
-  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement
     requirements:
     - *id003
-  type: :development
+  name: cucumber
+  prerelease: false
   version_requirements: *id004
+  type: :development
 - !ruby/object:Gem::Dependency
-  name: capybara
-  prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement
     requirements:
     - *id003
-  type: :development
+  name: capybara
+  prerelease: false
   version_requirements: *id005
+  type: :development
 - !ruby/object:Gem::Dependency
-  name: coveralls
-  prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement
     requirements:
     - *id003
-  type: :development
+  name: coveralls
+  prerelease: false
   version_requirements: *id006
+  type: :development
 - !ruby/object:Gem::Dependency
-  name: rack
-  prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement
     requirements:
     - *id003
-  type: :runtime
+  name: rack-test
+  prerelease: false
   version_requirements: *id007
+  type: :development
 - !ruby/object:Gem::Dependency
-  name: pygments.rb
-  prerelease: false
   requirement: &id008 !ruby/object:Gem::Requirement
     requirements:
     - *id003
-  type: :runtime
+  name: rack
+  prerelease: false
   version_requirements: *id008
+  type: :runtime
 - !ruby/object:Gem::Dependency
-  name: nokogiri
-  prerelease: false
   requirement: &id009 !ruby/object:Gem::Requirement
     requirements:
     - *id003
-  type: :runtime
+  name: pygments.rb
+  prerelease: false
   version_requirements: *id009
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  requirement: &id010 !ruby/object:Gem::Requirement
+    requirements:
+    - *id003
+  name: nokogiri
+  prerelease: false
+  version_requirements: *id010
+  type: :runtime
 description: Blogengine based on rack applications
 email:
 - klotz.benjamin@yahoo.de
@@ -100,9 +108,12 @@ files:
 - assets/config.yml
 - assets/content_error.content
 - assets/date_error.content
+- assets/date_test.content
 - assets/index.content
 - assets/layout.html
+- assets/operator.content
 - assets/operator.rb
+- assets/pygment.content
 - assets/title_error.content
 - bin/rack-blogengine
 - features/hello.feature
@@ -120,10 +131,13 @@ files:
 - rack-blogengine.gemspec
 - spec/rack/blogengine/document_spec.rb
 - spec/spec_helper.rb
+- tasks/default.rake
+- tasks/floodtest.rake
+- tasks/test.rake
 - test/rack/blogengine/application_router_test.rb
+- test/rack/blogengine/application_test.rb
 - test/rack/blogengine/command_line_interface_test.rb
 - test/rack/blogengine/document_parser_test.rb
-- test/rack/blogengine/document_test.rb
 - test/test_helper.rb
 homepage: http://www.bennyklotz.at
 licenses:
@@ -156,8 +170,7 @@ test_files:
 - spec/rack/blogengine/document_spec.rb
 - spec/spec_helper.rb
 - test/rack/blogengine/application_router_test.rb
+- test/rack/blogengine/application_test.rb
 - test/rack/blogengine/command_line_interface_test.rb
 - test/rack/blogengine/document_parser_test.rb
-- test/rack/blogengine/document_test.rb
 - test/test_helper.rb
-has_rdoc:

data/test/rack/blogengine/document_test.rb DELETED Viewed

@@ -1,48 +0,0 @@
-require 'test_helper.rb'
-#
-# TestClass for Documents
-#
-# @author [benny]
-#
-class DocumentTest < MiniTest::Unit::TestCase
-  def setup
-    @document = Rack::Blogengine::Document.new
-    @document.title = 'testtitle'
-    @document.path = '/test'
-    @document.date = '20-20-2014'
-    @document.html = '<html><h1>Test</h1></html>'
-  end
-  def test_new_document
-    assert_instance_of(Rack::Blogengine::Document, @document, 'Document should be of class Rack::Blogengine::Document')
-  end
-  def test_document_has_content
-    assert_equal('testtitle', @document.title, 'Document should contain the testtitle')
-    assert_equal('/test', @document.path, 'Document should contain the test path')
-    assert_equal('20-20-2014', @document.date, 'Document should contain the test date')
-    assert_equal('<html><h1>Test</h1></html>', @document.html, 'Document should contain the test html')
-  end
-  def test_document_to_hash
-    hashed = @document.to_hash
-    assert(hashed.key?(:path), 'Hashed Document should contain the path')
-    assert(hashed.key?(:html), 'Hashed Document should contain parsed html')
-  end
-  def test_exec_content_operator
-    cli = Rack::Blogengine::CommandLineInterface.new
-    capture_stdout { cli.generate(testpath) }
-    document = Rack::Blogengine::Document.new
-    document.html = '{% test_operator %}'
-    document.exec_content_operator(document, "#{testpath}")
-    assert_equal('test', document.html, 'Documents html should contain test_operators return value')
-    system("rm -rf #{testpath}")
-  end
-end