nanoc-oo 0.0.1

data/features/move_children.example

@@ -0,0 +1,43 @@
+@wip
+Feature: move children items
+
+  Background:
+    Given I have a blank wrapped nanoc site
+    And the folowing are input files:
+      """
+      content/one/index.html
+      content/one/item1.html
+      content/one/item2.html
+      content/two/index.html
+      """
+    And the folowing are expected output files:
+      """
+      output/one/index.html
+      output/two/index.html
+      output/two/item1/index.html
+      output/two/item2/index.html
+      """
+
+  Scenario:
+    Given the following empty files exist:
+      | content/one/index.html |
+      | content/one/item1.html |
+      | content/one/item2.html |
+      | content/two/index.html |
+    And a file named "lib/classes/classes.rb" with:
+      """
+        class One < Page
+          GOOD_ID = 'one'
+        end
+
+        class Two < Page
+          GOOD_ID = 'two'
+        end
+
+        class ThatItem < Page
+          GOOD_ID = 'one/*'
+        end
+      """
+    When I successfully compile it
+    Then input are the only files in "content" directory
+      And expected output are the only files in "output" directory

data/features/paginate_article.example

@@ -0,0 +1,86 @@
+Feature: paginate article example
+
+  Scenario:
+    Given I have a blank wrapped nanoc site
+    And a file named "content/article.html.md" with:
+      """
+      # First Header
+
+      ...
+
+      # Second Header
+
+      ...
+
+      # Third Header
+
+      ...
+
+      """
+    And a file named "lib/classes/articles.rb" with:
+      """
+      class Article < Page
+        GOOD_ID = //  # any item found
+
+        LAYOUT = '/article_contents/'  # replace original content using layout
+        
+        # create sub pages
+        def preprocess context
+          pages(item.raw_content).each_with_index do |page,index|
+            ArticlePage.create context, page, {}, %"#{identifier}#{index+1}/"
+          end
+        end
+
+        private
+        def pages content, one_page=/# .+?(?:(?=# )|\z)/m
+          content.scan(one_page).map &:strip
+        end
+      end
+
+      class ArticlePage < Page
+        GOOD_ID = nil  # only manual assignment by Page.create
+        EXT = 'html'   # for proper routing to index.html
+      end
+      """
+    And a file named "layouts/article_contents.slim" with:
+      """
+      - @title = /# (.*)$/
+      - for page in (+item).children
+        a href=page.path = page.raw_content[@title,1]
+      """
+    When I successfully compile it
+    Then the following files should exist:
+      |  output/article/index.html  |
+      | output/article/1/index.html |
+      | output/article/2/index.html |
+      | output/article/3/index.html |
+    And the file "output/article/index.html" should contain:
+      """
+      <a href="1/">First Header
+      """
+    And the file "output/article/index.html" should contain:
+      """
+      <a href="2/">Second Header
+      """
+    And the file "output/article/index.html" should contain:
+      """
+      <a href="3/">Third Header
+      """
+    And the file "output/article/1/index.html" should contain exactly:
+      """
+      # First Header
+
+      ...
+      """
+    And the file "output/article/2/index.html" should contain exactly:
+      """
+      # Second Header
+
+      ...
+      """
+    And the file "output/article/3/index.html" should contain exactly:
+      """
+      # Third Header
+
+      ...
+      """

data/features/step_definitions/complex_steps.rb

@@ -0,0 +1,23 @@
+def make_table array
+  table array.map { |str| [str] }
+end
+
+Step 'the folowing are * files:...' do |group, files|
+  (@groups ||= {})[group] = files.lines.map(&:strip).reject &:empty?
+end
+
+Step 'the * files should *exist' do |group, nt| # nt~not
+  step "the following files should #{nt}exist:", make_table(@groups[group])
+end
+
+Step '(the )?*( files)? are the only (ones|files) in( the)? "*" directory' do |group, dir|
+  really = nil
+  in_current_dir do
+    really = Dir[File.join(dir,'**/**')].to_a
+  end 
+  ideal = @groups[group]
+  extra = really - ideal
+  missing = ideal - really
+  step 'the following files should exist:', make_table(missing)
+  step 'the following files should not exist:', make_table(extra)
+end

data/features/step_definitions/nanoc-oo_steps.rb

@@ -0,0 +1,9 @@
+Given 'I have a wrapped default nanoc site' do
+  step '$ nanoc-oo site'
+  step 'I cd to "site"'  
+end
+
+Given 'I have a blank wrapped nanoc site' do
+  step '$ nanoc-oo site --blank'
+  step 'I cd to "site"'  
+end

data/features/step_definitions/nanoc_steps.rb

@@ -0,0 +1,22 @@
+Step '[>$] ?nanoc *' do |command|
+  step "I successfully run `ruby -S nanoc #{command}`"
+end
+
+Step '[>$] ?nanoc-oo *' do |command|
+  step "I successfully run `ruby -S nanoc-oo #{command}`"
+end
+
+Given 'I have a default nanoc site' do
+  step '$ nanoc create-site site'
+  step 'I cd to "site"'
+end
+
+When 'I successfully compile it' do
+  step '$ nanoc compile'
+  step 'it is successfully compiled'
+end
+
+Then 'it is successfully compiled' do
+  step 'a directory named "output" should exist'
+  step 'the file "crash.log" should not exist'
+end

data/features/step_definitions/steps.rb

@@ -0,0 +1 @@
+#Step 'the following files'

data/features/support/env.rb

@@ -0,0 +1,25 @@
+require 'aruba/cucumber'
+include FileUtils
+
+
+def clean_temp
+  rm_rf 'tmp'
+end
+AfterConfiguration do |config|
+  clean_temp
+end
+at_exit do
+  clean_temp
+end
+
+
+def copy_all params
+  from, to = params[:from], params[:to]
+  cp_r from, to
+end
+
+
+__END__
+ || undefined method 'feature' for ...ScenarioOutline...reporting.rb:101
+ \/ 
+ ENV['ARUBA_REPORT_DIR'] = 'doc_features'

data/features/support/my_extension.rb

@@ -0,0 +1,16 @@
+# tricky way to register .example files as cucumber features
+
+DEFAULT = /\*\.feature$/
+MODIFIED = '*.example'
+
+class Dir
+  class << self
+    alias _super []
+  end
+
+  def self.[] mask
+    return _super(mask) if mask !~ DEFAULT
+
+    _super(mask).to_a + _super(mask.sub(DEFAULT, MODIFIED)).to_a
+  end
+end

data/features/support/nice_steps.rb

@@ -0,0 +1,14 @@
+def full_line line
+  /^#{line}$/
+end
+
+def regex str
+  str.gsub!(/\(/, '(?:')
+  str.gsub!(/\*/, '(.*?)')
+  str.sub!(/\.\.\.$/, '.*')
+  full_line str
+end
+
+def Step step, &block
+  When regex(step), &block
+end

data/lib/nanoc-oo/version.rb

@@ -0,0 +1,3 @@
+module NanocOO
+  VERSION = "0.0.1"
+end

data/lib/nanoc-oo.rb

@@ -0,0 +1,25 @@
+require "nanoc-oo/version"
+
+module NanocOO
+  include FileUtils
+  
+  def create_site name, blank=false
+    `nanoc create-site #{name}`
+    wrap name
+    delete_content name if blank
+  end
+
+  def wrap dir
+    cp_r wrapper+'/.', dir
+  end
+
+  def wrapper
+    File.join Gem.datadir('nanoc-oo'),  'wrapper'
+  end
+
+  def delete_content dir
+    rm_r File.join(dir,'content')
+  end
+
+  extend self
+end

data/nanoc-oo.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nanoc-oo/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "nanoc-oo"
+  gem.version       = NanocOO::VERSION
+  gem.authors       = ['Alexander K']
+  gem.email         = ['xpyro@ya.ru']
+  gem.description   = %q{ with this you can map classes to directories and use inheritance in your nanoc site }
+  gem.summary       = %q{ nanoc wrapper with OO taste }
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'cucumber'
+  gem.add_development_dependency 'aruba'
+  gem.add_development_dependency 'slim'
+  gem.add_development_dependency 'nokogiri'
+  gem.add_development_dependency 'kramdown'
+  gem.add_development_dependency 'sass'
+
+  gem.add_dependency 'nanoc'
+  gem.add_dependency 'thor'
+
+  gem.executables << 'nanoc-oo'
+end

data/old-README.md

@@ -0,0 +1,72 @@
+# nanoc-OO [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/sowcow/nanoc-oo)
+
+* even more powerful nanoc (\*with object oriented taste\*)
+
+* the main idea is to decouple Rules file to classes \<link to feature>
+
+* by default files extensions are used to apply filters to layouts and items \<link to feature>
+
+* **pending** (+item).children is filled with children by default; some dsl to reuse items by assigning them as children to other items; compiling is guided by children tree
+
+## under the hood:
+
+* does not affect nanoc internals (and doesn't use them by now)
+* generates individual compile/route rules for each item
+* actually generates only one compile/route rule for root item, and it in turn generates rules for its children and so on
+* so there is kind of items for directories (`FakeDir`) to compile deeply seated items
+* `FakeItem` is kind of Nanoc::Item, that extracts `identifier` and `extension` from file name and has its own `#html?` and `#binary?` methods
+* `FakeItems` class is used to build array of items before even preprocessing stage
+* one instance of `Page`s subclasses is assigned for each item and it is accessible by `(+item)`; `(+item).item` is item itself
+* `Page`s are mostly configured by `CONSTANTS` or by methods that by default use that constants, both ways are inheritable by subclasses
+* any naming improvements or other thoughts are welcome
+
+## todo:
+
+1. children/parent
+1. Rules file:
+    * get rid of trash
+    * is it running twice (rspec)?
+1. cucumber features / examples
+1. extract methods from step definitions?
+1. layout in a class << !
+1. decouple specs
+1. comments -> specs
+1. improve rspec tables?
+1. ...
+
+## notes:
+ 
+### useful:
+
+ * relative paths filter is applying by default
+ * configureable
+
+### cryptic:
+
+ * specs for UndefinedPage?
+ * unused Hidable
+ * refactor:
+   * specs:
+     * refactor temp spec helpers
+     * refactor specs with true/false variant arrays
+     * use `context` properly (in specs)
+     * specs want to be cleaned
+     * refactor specs...
+     * fix specs: `it 'should work'`, `it 'routes properly'`, ...
+     * extract `"#{ SITE }/output/#{ name }..."`
+ * `'some.erb'.html?` 
+ * silent `no compilation rules found` by introducing empty compilation rule in `UndefinedPage`?
+ * use factories?  
+ * require inside code
+ * Rules file functions are passing params too much
+ * Rules:`unless item.is_a? FakeDir` is not tested decision
+ * unclear testing dependencies
+ * require FileUtils?
+ * fakeitem ~ nanocitem
+ * specs (lack of specification of code that is covered by features)
+   * binary?
+   * extension or ''
+   * raw_content
+   * EXT = , ID=nil, Page.create, ...
+ * (+item).parent?
+ * GOOD_ID= '*/some/**'

data/spec/add_item_spec.rb

@@ -0,0 +1,97 @@
+require 'support/all'
+require_lib
+
+
+describe 'Page#preprocess' do
+  let(:name){ 'test-page-preprocess' }
+
+  it 'should take context with items as parameter' do
+    Page.new('').method(:preprocess).arity.should == 1
+  end
+
+  describe '<context> argument' do
+
+    before do
+      TempFiles.create "#{ SITE }/lib/classes/#{ name }.rb" do
+        "
+        class TestingPage < Page
+          GOOD_ID = Regexp.new Regexp.escape '/#{ name }/'
+          #{ configuration }
+        end
+
+        class NewItems < Page
+          GOOD_ID = %r|item_|
+        end  
+        "
+      end
+    end      
+    before do
+      create_item("#{ name }.html.erb"){ '<strong><%= item[:value] %></strong>' }
+    end
+
+    describe 'value' do
+      let(:configuration) do
+        "
+        def preprocess context
+          item[:value] = context.items.count
+        end
+        "
+      end
+
+      it 'reflects items' do
+        compile!
+        output_file(name)[/<strong>(.+)<\/strong>/, 1].should == '1'
+      end
+    end
+
+    describe '<<' do
+      let(:configuration) do
+        '
+        def preprocess context
+          3.times do |counter|
+            context.items << Nanoc::Item.new("", {extension: \'html\'}, "/item_#{ counter }/")
+          end
+        end
+        '
+      end
+
+      it 'adds item' do
+        compile!
+        Dir["#{ SITE }/output/**/*.html"].count.should == 3 + 1  # "/#{ name }.html"
+      end
+    end
+    
+    describe 'reject!' do
+
+      context 'configuration 1' do
+        let(:configuration) do
+          '
+          def preprocess context
+            context.items.reject! { true }
+          end
+          '
+        end
+      
+        it 'removes items' do
+          compile!
+          Dir["#{ SITE }/output/**/*.html"].count.should == 0
+        end      
+      end
+      
+      context 'configuration 2' do
+        let(:configuration) do
+          '
+          def preprocess context
+            context.items.reject! { |those| those.identifier != identifier }
+          end
+          '
+        end
+      
+        it 'removes items' do
+          compile!
+          Dir["#{ SITE }/output/**/*.html"].count.should == 1
+        end      
+      end      
+    end    
+  end
+end

data/spec/cli/all_spec.rb

@@ -0,0 +1,57 @@
+require 'nanoc-oo'
+
+describe NanocOO do
+  include FileUtils
+
+  let(:temp){ 'temp' }
+  let(:site){ "#{temp}/site" }
+  before :each do
+    rm_rf temp
+  end  
+  after :each do
+    rm_rf temp
+  end
+
+  it 'creates site with nanoc' do
+    `nanoc-oo #{site}`
+    File.should exist join(site,'Rules')
+    Dir[join(site,'content')].count.should > 0
+  end
+
+  it 'creates site with nanoc (w/o cli)' do
+    NanocOO.create_site site
+    File.should exist join(site,'Rules')
+    Dir[join(site,'content')].count.should > 0
+  end
+
+  it 'creates site without content if --blank specified' do
+    `nanoc-oo #{site} --blank`
+    File.should exist join(site,'Rules')
+    Dir[join(site,'content')].count.should == 0
+  end
+
+  describe 'created site' do
+    before do
+      `nanoc-oo #{site}`
+    end
+
+    it 'is wrapped' do
+      read(join(site,'Rules')).should == read(join(NanocOO.wrapper,'Rules'))
+    end
+
+    context 'terminal outputs' do
+      specify 'nanoc output'
+      specify 'wrapping info'
+      specify '--help?'
+    end if false
+  end
+end
+
+BEGIN{
+  def join *a
+    File.join *a
+  end
+  def read *a
+    File.read *a
+  end
+}

data/spec/item_children_and_comiling_spec.rb

@@ -0,0 +1,97 @@
+require 'support/all'
+require_lib
+
+def chdir name
+  Dir.mkdir name
+  Dir.chdir name do
+    yield
+  end
+end
+
+def write file, text=lorem
+  File.write file, text
+end
+
+
+
+describe 'items compiling guided by children' do
+  before do
+    create_class do
+      "
+        class Test < Page
+          GOOD_ID = //
+        end
+      "
+    end
+  end
+
+  context 'just root item' do
+    before do
+      create_item('index.html'){ lorem }
+    end
+
+    it 'works' do
+      compile!
+      File.should exist "#{SITE}/output/index.html"
+    end
+  end
+
+  context 'just non-root item' do
+    let(:name){ 'non-root-item' }
+    before do
+      create_item("#{name}.html"){ lorem }
+    end
+
+    it 'works' do
+      compile!
+      File.should exist output name
+    end
+  end
+
+  context 'one deep seated item' do
+
+    let(:name){ 'deep/seated/item' }
+    before do
+      create_item("#{name}.html"){ lorem }
+    end
+
+    it 'works' do
+      compile!
+      File.should exist output name
+    end
+  end
+
+  context 'small tree of items with index.html files' do
+
+    let(:name){'some-temp-test-dir'}
+    let(:dir){"#{SITE}/content/#{name}"}
+    let(:text){ lorem }
+    after :all do
+      rm_rf dir
+    end
+    before :all do
+      chdir dir do
+        write 'index.html'
+        write 'file1.html'
+        chdir 'dir' do
+          write 'index.html'
+          write 'file2.html'
+          write 'file3.html'
+        end
+      end
+    end
+
+    it 'compiles nested files' do
+      compile!
+      File.should exist output "#{name}/file1"
+      File.should exist output "#{name}/dir/file2"
+      File.should exist output "#{name}/dir/file3"
+    end
+
+    it 'compiles index items' do
+      compile!
+      File.should exist output name
+      File.should exist output "#{name}/dir"
+    end
+  end  
+end