clerq 0.1.0 → 0.3.3

data/lib/clerq/interactors/query_nodes.rb

@@ -1,62 +0,0 @@
-# encoding: UTF-8
-
-require_relative "interactor"
-require_relative "join_nodes"
-
-module Clerq
-  module Interactors
-
-    class QueryNodes < Interactor
-
-      def call
-        proc = prepare_query
-        join = JoinNodes.()
-        list = join.select{|node| proc.call(node)}
-        return Node.new(title: "#{Clerq.settings.title}. Query: #{@query}") if list.empty?
-        make_response(list)
-      end
-
-      protected
-
-      def initialize(query:)
-        raise ArgumentError, "Invalid argument :query" if !(query.is_a?(String) && !query.empty?)
-        @query = query
-      end
-
-      def prepare_query
-        proc = Proc.new {|node| eval(@query)}
-        test = Node.new
-        test.select{|node| proc.call(node)}
-        proc
-      rescue Exception => e
-        msg = <<~EOF
-        Invalid query #{@query} (#{e.message})
-        It must eval as 'Proc.new{|node| eval(<query>)}'
-        Valid query examples are following:
-        node.id == 'uc'
-        node.belong?('uc')
-        node.belong?('ud') && node[:source] == 'sales'
-        EOF
-        raise self.class::Failure, msg
-      end
-
-      # @param nodes [Array<Node>] result of node.select
-      # @return [Node] node that includes all selected nodes
-      def make_response(nodes)
-        if nodes.size == 1
-          node = nodes.first
-          node.orphan!
-          return node
-        end
-        Node.new(id: @query).tap{|node|
-          nodes.each{|n|
-            n.orphan!
-            node << n
-          }
-        }
-      end
-
-    end
-
-  end
-end

data/lib/clerq/repositories/in_memory.rb

@@ -1,45 +0,0 @@
-require_relative 'repository'
-
-module Clerq
-  module Repositories
-
-    class InMemory < Repository
-
-      def initialize
-        @counter = 0
-        @items = {}
-      end
-
-      def items(id = nil)
-        return @items[id] if id
-        @items.values
-      end
-
-      def find(id)
-        @items[id]
-      end
-
-      def save(e)
-        raise ArgumentError, "Invalid argument" unless entity?(e)
-        id = has_id?(e) ? e.id : counter
-        @items[id] = e
-      end
-
-      protected
-
-        def counter
-          @counter += 1
-        end
-
-        def has_id?(e)
-          e.id && !e.id.empty?
-        end
-
-        def entity?(e)
-          e.is_a?(Object) && e.respond_to?(:id)
-        end
-
-    end
-
-  end
-end

data/lib/clerq/repositories/node_reader.rb

@@ -1,107 +0,0 @@
-# encoding: UTF-8
-
-require_relative '../entities'
-include Clerq::Entities
-
-module Clerq
-  module Repositories
-  end
-end
-
-class Clerq::Repositories::NodeReader
-
-  # @param [String] file_name with node
-  # @return [Array<Node>] from file
-  def self.call(file_name)
-    new(file_name).call
-  end
-
-  # @param [Enumerator] lines; for testing purpose
-  # @return [Array<Node>] from file
-  def call(text = File.foreach(@file_name))
-    STDOUT.print "Reading #{@file_name} ..."
-
-    read_nodes(text).each do |node_text|
-      level, node = parse_node(node_text)
-      next unless node
-      node[:file_name] = @file_name
-      insert_node(node, level)
-    end
-
-    STDOUT.puts @errors.empty? ? "OK" : "Errors found"
-    unless @errors.empty?
-      STDERR.puts "Errors reading #{@file_name}"
-      STDERR.puts @errors.map{|e| "\t#{e}"}.join("\n")
-    end
-
-    nodes = Array.new(@node.items)
-    nodes.each(&:orphan!)
-    nodes
-  end
-
-  protected
-
-    def initialize(file_name)
-      @file_name = file_name
-      @node = Node.new(id: file_name)
-      @errors = []
-    end
-
-    # @param [Enumerator<String>] text
-    # @return [Array<String>] where each item represents one node
-    def read_nodes(text)
-      [].tap do |nodes|
-        quote, body = false, ''
-        text.each do |line|
-          if line.start_with?('#') && !quote && !body.empty?
-            nodes << body
-            body = ''
-          end
-          body << line
-          quote = !quote if line.start_with?('```')
-        end
-        nodes << body unless body.empty?
-      end
-    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
-        @errors << "invalid header level: #{'#' * level} [#{node.id}]"
-        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
-      @errors << "invalid node format:\n#{text}"
-      [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
-      @errors << "invalid meta format:\n{{#{text}}}"
-      {}
-    end
-
-    NODE_REGX =
-      /^(\#+)[ ]*(\[([^\[\]\s]*)\][ ]*)?([\s\S]*?)\n({{([\s\S]*?)}})?(.*)$/m
-
-end

data/lib/clerq/repositories/repository.rb

@@ -1,11 +0,0 @@
-module Clerq
-  module Repositories
-
-    class Repository
-      def items(id = nil); end
-      def find(id); end
-      def save(e); end
-    end
-
-  end
-end

data/lib/clerq/repositories/template_repository.rb

@@ -1,53 +0,0 @@
-# encoding: UTF-8
-
-require_relative '../entities'
-require_relative 'repository'
-include Clerq::Entities
-
-module Clerq
-  module Repositories
-
-    class TemplateRepository < Repository
-      attr_reader :path
-      def initialize(path = Dir.pwd)
-        @items = {}
-        @path = path
-      end
-
-      # TODO move id parameter to #find
-      def items(id = nil)
-        load if @items.empty?
-        return find(id) if id
-        @items.values
-      end
-
-      def find(id)
-        return @items[id] if @items[id]
-        PATTERNS.each do |p|
-          i0 = "#{id}#{p[1..-1]}"
-          return @items[i0] if @items[i0]
-        end
-        return nil
-      end
-
-      def save(tt)
-        raise ArgumentError, "Invalid argument" unless tt.is_a? Template
-        Dir.chdir(@path){ File.write(tt.id, tt.body) }
-      end
-
-      protected
-
-      def load
-        Dir.chdir(@path) do
-          Dir.glob(PATTERNS)
-            .map {|f| Template.new(id: f, body: File.read(f))}
-            .each{|t| @items[t.id] = t}
-        end
-      end
-
-      PATTERNS = ['*.tt', '*.erb']
-
-    end
-
-  end
-end

data/lib/clerq/templater.rb

@@ -1,32 +0,0 @@
-# encoding: UTF-8
-
-require 'erb'
-
-module Clerq
-
-  # Compile @object to text in accordance with @template
-  # Usage
-  #   tt = "id: <%= @object.id %>\ntitle: <%= @object.title %>\n"
-  #   n = Node.new(id: 'uc', title: 'Use Cases', meta: {skip_meta: true})
-  #   text = Templater.call(tt, n) # or Templater.(tt, n)
-  class Templater
-
-    # @param tt [Template]
-    # @param object [Object]
-    # @result [String?]
-    def self.call(template, object)
-      new(template, object).call
-    end
-
-    def call
-      tt = ERB.new(@template, nil, "-")
-      tt.result(binding)
-    end
-
-    def initialize(template, object)
-      @template = template
-      @object = object
-    end
-  end
-
-end