clerq 0.2.0 → 0.3.0

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,24 +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
 
     # 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 < Interactor
+    class CreateNode < Service
 
       def call
         @body = QueryTemplate.(@template) if @body.empty? && !@template.empty?
         @node = Clerq::Entities::Node.new(
           id: @id, title: @title, body: @body, meta: @meta)
         Clerq.node_repository.save(@node)
-      rescue StandardError => e
-        raise Failure, e.message
       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

data/lib/clerq/{interactors/query_assembly.rb → services/query_node.rb}

@@ -1,16 +1,16 @@
 # encoding: UTF-8
 
-require_relative "interactor"
+require_relative "service"
 
 module Clerq
-  module Interactors
+  module Services
 
     # Provides repository nodes assembly
     # @param [Sring] optional query string
     # @return [Node] assembly of repository nodes
     #
     # Usage
-    #   QueryAssembly.()
+    #   QueryAssembly.(asse:, query:)
     #   QueryAssembly.(query_string)
     #
     # Rules for root node:
@@ -20,14 +20,12 @@ module Clerq
     #   when query returns mare than one nodes, then
     #     * it creates empty root node with meta[:query]
     #     * and places found nodes to the root
-    class QueryAssembly < Interactor
+    class QueryNode < Service
 
       def call
         proc = prepare_query unless @query.empty?
-        join = Clerq.node_repository.assemble
-        return join if @query.empty?
 
-        arry = join.select{|node| proc.call(node) }
+        arry = @assembly.select{|node| proc.call(node) }
         return arry.first.orphan! if arry.size == 1
 
         node = Node.new(title: Clerq.title, meta: {query: @query})
@@ -37,12 +35,17 @@ module Clerq
 
       protected
 
-      def initialize(query = '')
+      def initialize(assembly: , query: )
+        unless assembly.is_a? Node
+          msg = "Invailid argument 'assembly'"
+          raise ArgumentError, msg
+        end
         unless query.is_a? String
           msg = "Invailid argument 'query'"
           raise ArgumentError, msg
         end
         @query = query
+        @assembly = assembly
       end
 
       def prepare_query
@@ -50,13 +53,13 @@ module Clerq
         Node.new.select{|node| proc.call(node)}
         proc
       rescue Exception => e
-        msg = "Invalid query #{@query} (#{e.message})\n#{USAGE}"
-        raise self.class::Failure, msg
+        msg = "Invalid query format #{@query} (#{e.message})\n#{USAGE}"
+        raise ArgumentError, msg
       end
 
       USAGE = <<~EOF
-        QueryNode.call(query) evaluates query paramater
-        by eval() as 'Proc.new { |node| eval(@query) }'
+        QueryAssembly.call(query: ) evaluates query paramater
+        by eval() as 'Proc.new { |node| eval(query) }'
         e.g. the followed queries are valid:
           node.id == 'uc'
           node.title == 'Introduction'

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

@@ -1,19 +1,14 @@
 # encoding: UTF-8
 
-require_relative "interactor"
+require_relative "service"
 
 module Clerq
-  module Interactors
+  module Services
 
-    class QueryTemplate < Interactor
-
-      private_class_method :new
+    class QueryTemplate < Service
 
       def call
         Clerq.text_repository.text(@template)
-      rescue StandardError
-        err = "'#{@template}' template not found!"
-        raise Failure, err
       end
 
       # @param template [String] required name of template

data/lib/clerq/services/read_node.rb

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+require_relative 'service'
+require_relative '../entities/node'
+include Clerq::Entities
+
+module Clerq
+  module Services
+
+    # The service reads nodes from file and returns array of nodes
+    # It returns array because the file can have a few root nodes
+    class ReadNode < Service
+
+      def call
+        text = File.foreach(@filename)
+        read_nodes(text) do |node_text|
+          level, node = parse_node(node_text)
+          next unless node
+          node[:filename] = @filename
+          insert_node(node, level)
+        end
+
+        ary = Array.new(@node.items)
+        ary.each(&:orphan!)
+        ary
+      end
+
+      # @param filename [String] input file for reading
+      # @param on_error [Proc] proc object {|error| ...}
+      def initialize(filename, on_error = nil)
+        @filename = filename
+        @on_error = on_error
+        @node = Node.new(id: filename)
+      end
+
+      protected
+
+      # @param [Enumerator<String>] text
+      # @return [Array<String>] where each item represents one node
+      def read_nodes(text, &block)
+        quote, node = false, []
+        text.each do |line|
+          if line.start_with?('#') && !quote && !node.empty?
+            block.call(node.join("\n"))
+            node = []
+          end
+          node << line
+          quote = !quote if line.start_with?('```')
+        end
+        block.call(node.join("\n")) unless node.empty?
+      end
+
+      def insert_node(node, level)
+        parent = @node
+        while parent.last_item && (parent.nesting_level + 1) < level
+          parent = parent.last_item
+        end
+        unless (parent.nesting_level + 1) == level
+          msg = "invalid header level: #{'#' * level} #{node.title}"
+          @on_error.call(msg) if @on_error
+          parent = @node
+        end
+        parent << node
+      end
+
+      def parse_node(text)
+        text += "\n" unless text.end_with?("\n")
+        parts = NODE_REGX.match(text)
+        lv = parts[1] || ''
+        id = parts[3] || ''
+        title = parts[4] || ''
+        body = parts[7] || ''
+        meta = {}
+        meta.merge!(parse_meta(parts[6])) if parts[6]
+        [lv.size, Node.new(id: id, title: title, body: body.strip, meta: meta)]
+      rescue StandardError
+        msg = "invalid node format: #{text}"
+        @on_error.call(msg) if @on_error
+        [nil, nil]
+      end
+
+      def parse_meta(text)
+        text.strip.split(/[;,\n]/).inject({}) do |h, i|
+          pair = /\s?(\w*):\s*(.*)/.match(i)
+          h.merge(pair[1].to_sym => pair[2])
+        end || {}
+      rescue StandardError
+        msg = "invalid meta format:\n{{#{text}}}"
+        @on_error.call(msg) if @on_error
+        {}
+      end
+
+      NODE_REGX =
+        /^(\#+)[ ]*(\[([^\[\]\s]*)\][ ]*)?([\s\S]*?)\n({{([\s\S]*?)}})?(.*)$/m
+
+    end
+
+  end
+end

data/lib/clerq/services/render_erb.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+require 'erb'
+require_relative 'service'
+
+module Clerq
+  module Services
+
+    # Render @object trough ERB temlate
+    #
+    # Usage
+    #   erb = "id: <%= @object.id %>\ntitle: <%= @object.title %>\n"
+    #   obj = Node.new(id: 'uc', title: 'Use Cases', meta: {skip_meta: true})
+    #   txt = RenderErb.call(erb, obj) # or RenderErb.(erb, obj)
+    class RenderErb < Service
+
+      def call
+        tt = ERB.new(@erb, nil, "-")
+        tt.result(binding)
+      end
+
+      def initialize(erb: , object: )
+        @erb = erb
+        @object = object
+      end
+    end
+
+  end
+end

data/lib/clerq/{interactors/render_assembly.rb → services/render_node.rb}

@@ -1,26 +1,22 @@
 # encoding: UTF-8
-require_relative 'interactor'
-require_relative '../render_erb'
+require_relative 'service'
+require_relative 'query_template'
+require_relative 'render_erb'
 
 module Clerq
-  module Interactors
+  module Services
 
-    class RenderAssembly < Interactor
+    class RenderNode < Service
 
       def call
         @erb = QueryTemplate.(@ett)
-        asmb = QueryAssembly.(@qry)
-        RenderErb.(erb: @erb, object: asmb)
-        # TODO Clerq.binaries.save(@out, text)
-      rescue StandardError => e
-        raise Failure, e.message
+        RenderErb.(erb: @erb, object: @node)
       end
 
-      def initialize(template:, query: '')
+      def initialize(node: , template:)
         check_string_argument!(template, 'template')
         check_string_empty!(template, 'template')
-        check_string_argument!(query, 'query')
-        @qry = query
+        @node = node
         @ett = template
       end