clerq 0.1.0 → 0.3.3

data/lib/clerq/properties.rb

@@ -4,9 +4,7 @@ module Clerq
     def property(name, options = {}, &validation)
       default_value = options[:default]
       define_method name do
-        v = instance_variable_get("@#{name}")
-        v = default_value unless v
-        v
+        instance_variable_get("@#{name}") || default_value
       end
 
       define_method "#{name}=" do |val|

data/lib/clerq/repositories.rb

@@ -1,5 +1,3 @@
-require_relative 'repositories/repository'
-require_relative 'repositories/in_memory'
-require_relative 'repositories/node_reader'
+require_relative 'repositories/file_repository'
 require_relative 'repositories/node_repository'
-require_relative 'repositories/template_repository'
+require_relative 'repositories/text_repository'

data/lib/clerq/repositories/file_repository.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+module Clerq
+  module Repositories
+
+    # The class provides File and Dir functions that executed relativly path
+    #   provided in constructor.
+    #
+    # Usage:
+    #   FileRepository.new(path: Dir.pwd, pattern: '*.*')
+    #   FileRepository.new(path: Dir.pwd, pattern: ['*.rb', '*.md'])
+    class FileRepository
+      attr_reader :path
+      attr_reader :patt
+
+      # @param path [String]
+      # @param pattern [String, Array<String>]
+      def initialize(path: Dir.pwd, pattern: '*.*')
+        # TODO check that path exists and save it in full form
+        unless Dir.exist?(path)
+          msg = "'#{path}' directory does not exist!"
+          raise ArgumentError, msg
+        end
+        @path = path
+        @patt = pattern
+      end
+
+      def inside
+        Dir.chdir(@path) { yield }
+      end
+
+      protected
+
+      # @param pattern [String, Array<String>]
+      def glob(pattern = '')
+        pt = pattern.empty? ? @patt : pattern
+        pt = [pt] if pt.is_a?(String)
+        pt = pt.map{|p| p = File.join('**', p)}
+        Dir.chdir(@path) { Dir.glob pt }
+      end
+
+      def read(filename)
+        File.read(File.join @path, filename)
+      end
+
+      def write(filename, content)
+        join = File.join(@path, filename)
+        if File.exist?(join)
+          errmsg = "File '#{join}' alredy exists!"
+          raise StandardError, errmsg
+        end
+        File.write(join, content)
+        join
+      end
+
+    end
+
+  end
+end

data/lib/clerq/repositories/node_repository.rb

@@ -1,55 +1,97 @@
 # encoding: UTF-8
 
 require_relative '../entities'
-require_relative 'repository'
+require_relative 'file_repository'
+require_relative '../services/read_node'
 include Clerq::Entities
+include Clerq::Services
 
 module Clerq
   module Repositories
 
-    class NodeRepository < Repository
-      def initialize(path = Dir.pwd)
-        @path = path
-        @items = []
-      end
+    class NodeRepository < FileRepository
 
-      def items(id = nil)
-        load_nodes if @items.empty?
-        return @items.find {|i| i.id == id} if id
-        @items
+      def initialize(path: Dir.pwd, pattern: '*.md')
+        super(path: path, pattern: pattern)
       end
 
       def save(node)
-        raise ArgumentError, "Invalid argument" unless node.is_a? Node
-        Dir.chdir(@path){ File.write(node.id + '.md', markdown(node))}
+        check! node
+        write("#{node.id}.md", markup(node))
+      end
+
+      # asseble repository nodes hierarchy
+      # @return [Node]
+      def assemble(on_parse: nil, on_error: nil)
+        @node = Node.new(id: 'join', title: Clerq.title)
+        loadn = load(on_parse: on_parse, on_error: on_error)
+        loadn.each{|n| @node << n}
+        subo!
+        eqid!
+        if @node.items.size == 1
+          @node = @node.items.first
+          @node.orphan!
+        end
+        @node
       end
 
       protected
 
-        def load_nodes
-          @items = []
-          Dir.chdir(@path) do
-            Dir.glob('**/*.md').each do |f|
-              # TODO: what to do with errors?
-              nodes = NodeReader.(f)
-              nodes.each{|n| @items << n}
+      def load(on_parse: nil, on_error: nil)
+        inside do
+          [].tap do |ary|
+            glob.each do |file|
+              on_parse.call(file) if on_parse
+              tmp = ReadNode.(file, on_error)
+              tmp.each{|node| ary << node }
             end
           end
         end
+      end
 
-        def markdown(n)
-          [].tap do |out|
-            out << "#{'#' * (n.nesting_level + 1)} [#{n.id}] #{n.title}"
-            unless n.meta.empty?
-              out << '{{'
-              n.meta.each{|k,v| out << "#{k}: #{v}"}
-              out << '}}'
-              out << "\n"
-            end
-            out << n.body
-          end.join("\n")
+      def subo!
+        @node.items
+          .select{|n| n[:parent] && n[:parent] != n.parent.id}
+          .each{|n|
+            parent = @node.node(n[:parent])
+            next unless parent
+            parent << n
+            @node.items.delete(n)
+            n.meta.delete(:parent)
+          }
+      end
+
+      def eqid!
+        counter = {}
+        @node.select{|n| n.id.empty?}.each do |n|
+          # TODO maybe just .to_a.drop(1).select ?
+          next if n == @node
+          index = counter[n.parent] || 1
+          counter[n.parent] = index + 1
+          id = index.to_s.rjust(2, '0')
+          id = '.' + id unless n.parent == @node
+          n.id = id
         end
+      end
 
+      def check!(node)
+        return if node.is_a? Node
+        errmsg = "Invalid argument"
+        raise ArgumentError, errmsg, caller #caller[1..-1]
+      end
+
+      def markup(n)
+        head = "# [#{n.id}] #{n.title}"
+        meta = n.meta.empty? ? '' : n.meta
+          .map{|k,v| "#{k}: #{v}"}
+          .unshift("{{")
+          .push("}}")
+          .join("\n")
+        [head].tap do |txt|
+          txt << "\n#{meta}" unless meta.empty?
+          txt << "\n\n#{n.body}" unless n.body.empty?
+        end.join + "\n"
+      end
     end
 
   end

data/lib/clerq/repositories/text_repository.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+require_relative 'file_repository'
+
+module Clerq
+  module Repositories
+
+    class TextRepository < FileRepository
+
+      def initialize(path: Dir.pwd, pattern: ['*.md.erb', '*.md.tt'])
+        super(path: path, pattern: pattern)
+      end
+
+      # Return template body @param name [String]
+      def text(name)
+        filename = find(name)
+        if filename.empty?
+          err = "File '#{name}' not found"
+          raise StandardError, err
+        end
+        read(filename)
+      end
+
+      # def find(filename)
+      #   inside do
+      #     return filename if File.exist?(filename)
+      #     @patt.each do |p|
+      #       fn = "#{filename}#{p[1..-1]}"
+      #       return fn if File.exist?(fn)
+      #     end
+      #   end
+      #   ''
+      # end
+
+      def find(name)
+        inside {
+          return name if File.exist?(name) and !File.directory?(name)}
+        all = glob
+        pos = @patt.map{|p| "#{name}#{p[1..-1]}"}.unshift(name)
+        all.find(lambda {''}){|n|
+          pos.include?(n) || n.start_with?(*pos) || n.end_with?(*pos)
+        }
+      end
+
+    end
+
+  end
+end

data/lib/clerq/services.rb

@@ -0,0 +1,8 @@
+require_relative 'services/service'
+require_relative 'services/check_assembly'
+require_relative 'services/read_node'
+require_relative 'services/load_assembly'
+require_relative 'services/query_node'
+require_relative 'services/query_template'
+require_relative 'services/create_node'
+require_relative 'services/render_node'

data/lib/clerq/services/check_assembly.rb

@@ -0,0 +1,108 @@
+# encoding: UTF-8
+
+require_relative 'service'
+
+module Clerq
+  module Services
+
+    # Find errors in hierarchy and prints in console
+    class CheckAssembly < Service
+
+      private_class_method :new
+
+      def call
+        print_nonuniq_id
+        print_lost_roots
+        print_lost_index
+        print_lost_links
+      end
+
+      protected
+
+      def nonuniq_id
+        @node.inject({}) do |memo, node|
+          memo[node.id] ||= []
+          memo[node.id] << node
+          memo
+        end.select{|_, v| v.size > 1}
+      end
+
+      def print_nonuniq_id
+        errors = nonuniq_id
+        print "Checking for duplicates in node ids... "
+        puts errors.empty? ? 'OK' : "#{errors.size} found"
+        errors.each do |id, nodes|
+          occs = nodes.map{|n| n[:filename]}
+            .group_by{|i| i}
+            .map{|k,v| [v.size, k]}
+            .sort{|a, b| b.first <=> a.first}
+            .map{|i| n, src = i; "#{how_many_times(n)} in '#{src}'"}
+          occurrences = occs.join(occs.size == 2 ? ' and ' : ', ')
+          puts "- [#{id}] occured #{occurrences}"
+        end
+      end
+
+      def print_lost_roots
+        lost = @node.select{|n| n[:parent] && n.parent.id != n[:parent]}
+        print "Checking for lost roots in node parents... "
+        puts lost.empty? ? 'OK' : "#{lost.size} found"
+        lost.each do |n|
+          puts "- {{parent: #{n[:parent]}}} of '#{n.id}' in '#{n[:filename]}'"
+        end
+      end
+
+      def print_lost_index
+        errors = @node
+          .reject{|n| n.order_index.empty?}
+          .inject({}) do |memo, n|
+            lost = n.order_index.reject{|o| n.item(o)}
+            memo[n] = lost unless lost.empty?
+            memo
+          end
+
+        print "Checking for lost items in order_index... "
+        puts errors.empty? ? 'OK' : "#{errors.size} found"
+        errors.each do |n, lost|
+          puts "- {{order_index: #{lost.join(' ')}}} not found of node '#{n.id}' in '#{n[:filename]}'"
+        end
+      end
+
+      def lost_links
+        index = @node.map(&:id).drop(1).uniq
+        @node.inject({}) do |memo, node|
+          node.links
+            .reject{ |lnk| index.include?(lnk) || @node.node(lnk)}
+            .each do |lnk|
+              memo[lnk] ||= []
+              memo[lnk] << node
+            end
+          memo
+        end
+      end
+
+      def print_lost_links
+        errors = lost_links
+        print "Checking for lost links in nodes body... "
+        puts errors.empty? ? 'OK' : "#{errors.size} found"
+        errors.each do |link, arry|
+          where = arry.map{|n| "[#{n.id}] of '#{n[:filename]}'"}.join(', ')
+          puts "- [[#{link}]] in #{where}"
+        end
+      end
+
+      # humanize number of how many times the error occurred in one file
+      def how_many_times(n)
+        case n
+        when 1 then 'once'
+        when 2 then 'twice'
+        else "#{n} times"
+        end
+      end
+
+      def initialize(node)
+        @node = node
+      end
+    end
+
+  end
+end

data/lib/clerq/{interactors → services}/create_node.rb

@@ -1,22 +1,23 @@
 # encoding: UTF-8
 
-require_relative "interactor"
+require_relative "service"
+require_relative "query_template"
+require_relative "../entities/node"
 
 module Clerq
-  module Interactors
+  module Services
 
-    class CreateNode < Interactor
+    # Creates new node in repository according to provided parameters
+    # or raises CreateNode::Failure when
+    #   * template not found
+    #   * or repository contains a node with the same id
+    class CreateNode < Service
 
       def call
-        unless @template.empty?
-          tt = gateway.templates(@template)
-          raise Failure, "Template not found" unless tt
-# TODO not just `@body = tt.body` but build `@body` in accordance with tt.body
-          @body = tt.body
-        end
-        node = Clerq::Entities::Node.new(
+        @body = QueryTemplate.(@template) if @body.empty? && !@template.empty?
+        @node = Clerq::Entities::Node.new(
           id: @id, title: @title, body: @body, meta: @meta)
-        gateway.save(node)
+        Clerq.node_repository.save(@node)
       end
 
       protected

data/lib/clerq/services/load_assembly.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+require_relative 'service'
+
+module Clerq
+  module Services
+
+    # The service returns assembly and prints progress in console
+    class LoadAssembly < Service
+      def call
+        memo = {}
+        on_parse_callback = lambda do |src|
+          puts "Reading '#{src}'..."
+          memo[src] = 0
+        end
+        on_error_callback = lambda do |err|
+          puts "\t#{err}"
+          memo[memo.keys.last] += 1
+        end
+
+        puts "Loading repository..."
+        assemble = Clerq.assemble(
+          on_parse: on_parse_callback,
+          on_error: on_error_callback)
+
+        if memo.empty?
+          puts "This repository is empty"
+        else
+          errors_count = memo.values.inject(0, &:+)
+          message = [].tap do |m|
+            m << "#{nos(memo.size, 'file')} loaded"
+            m << "#{nos(errors_count, 'error')} detected"
+          end.join(', ')
+          puts message
+        end
+        
+        assemble
+      end
+
+      protected
+
+      # TODO 0 zero, no
+      def nos(number, subject)
+        case number
+        when 0 then "no #{subject}s"
+        when 1 then "one #{subject}"
+        when 2 then "two #{subject}s"
+        else "#{number} #{subject}s"
+        end
+      end
+
+    end
+
+  end
+end