klue-langcraft 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '07528e25c004b36664752d235737a9f6f521e231eb2b9e900884861e2fbeccad'
-  data.tar.gz: bd96ac7b1247f8f4fe123b4bb7923df50f1067120b1faa6e1121c6936fe400d1
+  metadata.gz: 586607de2048a4670a8cc9cd1e06dd9a2d1636aa0c9825698af2b6bac51ea24d
+  data.tar.gz: 1973c38bf614abc045c9d8e2759f984791b52da023d10441d2564bf54f99c323
 SHA512:
-  metadata.gz: f270af8583b0ef01f5c290f0d69abe2de5534682169440381532fea9510c0b2b03f7c247c13dcde3fd13dc88b89fdadc3255af804138b6373513ea16a32b31d6
-  data.tar.gz: e23279553bc9f644ebe56ce796dd99cda278c10170142806e2a9ed59839a3a51a541de9b0b75082474e46f130cd6e3e5d037d2c5e9c475585280ba032d84a6d8
+  metadata.gz: 9c20cb42da33cc805d4ec372f6101f796b44d127724fd1a611cd2620e4614e225148fc2162ab6f0e8d9bdf2fa1909575f0ed78da93ba057b4af38415bae739bd
+  data.tar.gz: 4ebe337655eba091ec8013700734afcea0a67006bc076ac5d94e075d4210fba5ee490e43f4eb92c716e2230d5c61918ce201fecde6b6919a081bfea1a95088c9

data/.rubocop.yml

@@ -40,8 +40,23 @@ Metrics/BlockLength:
     - shared_examples_for
     - transaction
 
+Metrics/AbcSize:
+  Exclude:
+    - bin/*
+
+
 Metrics/MethodLength:
   Max: 25
+  Exclude:
+    - bin/*
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - bin/*
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - bin/*
 
 Layout/LineLength:
   Max: 200
@@ -55,7 +70,7 @@ Lint/UnusedMethodArgument:
 Style/BlockComments:
   Enabled: false
   Include:
-    - "**/spec/*"
+    - "**/spec/**/*"
 
 # My Preferences - Start
 Metrics/ClassLength:
@@ -75,8 +90,8 @@ Style/EmptyMethod:
   Exclude:
     - "**/spec/**/*"
 Metrics/ParameterLists:
-  Exclude:
-    - "**/spec/**/*"
+  Enabled: false
+
 Layout/EmptyLineBetweenDefs:
   Exclude:
     - "**/spec/**/*"

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.2.0](https://github.com/appydave/klue-langcraft/compare/v0.1.1...v0.2.0) (2024-10-25)
+
+
+### Bug Fixes
+
+* fix ci issue ([a3bfd35](https://github.com/appydave/klue-langcraft/commit/a3bfd35371b7c0ca70b0b57d70d4541c7a4ec54b))
+* fix cop ([123070b](https://github.com/appydave/klue-langcraft/commit/123070bd1f636a81d01da469c2e5072c57384bae))
+* update dsl_interpreter ([2507045](https://github.com/appydave/klue-langcraft/commit/2507045c3f7f205603a3f899785e9c5445c4c0bb))
+
+
+### Features
+
+* refactor dsl processor ([5875dc9](https://github.com/appydave/klue-langcraft/commit/5875dc957789f113da762a6dcb55cda66bfb8a3d))
+
 ## [0.1.1](https://github.com/appydave/klue-langcraft/compare/v0.1.0...v0.1.1) (2024-09-22)
 
 

data/bin/langcraft.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'klue/langcraft'
+require 'optparse'
+
+# CLI class for the Klue Langcraft application.
+# This class handles command-line interactions, parsing options,
+# and executing the appropriate commands for processing files
+# or watching directories.
+class CLI
+  def initialize
+    @commands = {
+      'process' => method(:process_files),
+      'watch' => method(:watch_files)
+    }
+  end
+
+  def run
+    if ARGV.empty?
+      print_help
+      exit
+    end
+
+    command, *args = ARGV
+    if @commands.key?(command)
+      @commands[command].call(args)
+    else
+      puts "Unknown command: #{command}"
+      print_help
+    end
+  end
+
+  private
+
+  def process_files(args)
+    options = {}
+    parser = OptionParser.new do |opts|
+      opts.banner = 'Usage: langcraft process [options]'
+
+      opts.on('-i', '--input FILE', 'Input file (required)') do |file|
+        options[:input] = file
+      end
+
+      opts.on('-b', '--basic-output FILE', 'Output file') do |file|
+        options[:basic_output] = file
+      end
+
+      opts.on('-e', '--enhanced-output FILE', 'Output file') do |file|
+        options[:enhanced_output] = file
+      end
+
+      opts.on('-u', '--webhook-url URL', 'Webhook URL') do |url|
+        options[:webhook_url] = url
+      end
+
+      opts.on('-d', '--debug LEVEL', %i[none info detailed], 'Debug level (none, info, detailed)') do |level|
+        options[:debug] = level
+      end
+
+      opts.on('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+    end
+
+    parser.parse!(args)
+
+    if validate_options(options)
+      run_klue_runner(options)
+    else
+      print_usage(parser)
+    end
+  end
+
+  def validate_options(options)
+    if options[:input].nil?
+      puts 'Error: Input file is required.'
+      false
+    else
+      true
+    end
+  end
+
+  def run_klue_runner(options)
+    klue_runner = Klue::Langcraft::DSL::KlueRunner.new
+    klue_runner.run(
+      input_file: options[:input],
+      basic_output_file: options[:basic_output],
+      enhanced_output_file: options[:enhanced_output],
+      webhook_url: options[:webhook_url],
+      debug: options[:debug] || :none
+    )
+  rescue StandardError => e
+    puts "Error: #{e.message}"
+    exit 1
+  end
+
+  def print_usage(parser)
+    puts 'Error: Invalid or missing options.'
+    puts
+    puts parser
+    exit 1
+  end
+
+  def watch_files(args)
+    options = {
+      directories: [],
+      create_basic_json: false,
+      create_enhanced_json: false,
+      log_level: :info,
+      webhook_url: nil,
+      extensions: ['.klue'] # Default extension
+    }
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: server watch [options]'
+
+      opts.on('-w', '--watch-directory DIRECTORY', 'Directory to watch (can be specified multiple times)') do |dir|
+        options[:directories] << File.expand_path(dir) # Expand the path here
+      end
+
+      opts.on('-f', '--flags TYPE', 'Set processing flags (none, basic, enhanced, all)') do |type|
+        types = type.split(',').map(&:strip).map(&:downcase)
+        options[:create_basic_json] = types.include?('basic') || types.include?('all')
+        options[:create_enhanced_json] = types.include?('enhanced') || types.include?('all')
+      end
+
+      opts.on('-l', '--log-level LEVEL', %i[none info detailed], 'Log level (none, info, detailed)') do |level|
+        options[:log_level] = level
+      end
+
+      opts.on('-u', '--webhook-url URL', 'Webhook URL') do |url|
+        options[:webhook_url] = url
+      end
+
+      opts.on('-e', '--extensions EXT1,EXT2,...', Array, 'File extensions to watch (default: .klue)') do |exts|
+        options[:extensions] = exts.map { |ext| ext.start_with?('.') ? ext : ".#{ext}" }
+      end
+
+      opts.on('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+    end.parse!(args)
+
+    # If no directories were specified, use the current directory
+    options[:directories] = [Dir.pwd] if options[:directories].empty?
+
+    # Ensure all directories are expanded
+    options[:directories].map! { |dir| File.expand_path(dir) }
+
+    Klue::Langcraft::DSL::Watcher.new(
+      options[:directories],
+      create_basic_json: options[:create_basic_json],
+      create_enhanced_json: options[:create_enhanced_json],
+      log_level: options[:log_level],
+      webhook_url: options[:webhook_url],
+      extensions: options[:extensions]
+    ).start
+  end
+
+  def print_help
+    puts 'Klue Langcraft Server'
+    puts 'Usage: server [command] [options]'
+    puts ''
+    puts 'Commands:'
+    puts '  process  Process a single file'
+    puts '  watch    Watch directories for changes'
+    puts ''
+    puts "Run 'server [command] --help' for more information on a command."
+  end
+end
+
+# Run the CLI
+CLI.new.run

data/lib/klue/langcraft/dsl/interpreter.rb

@@ -17,18 +17,18 @@ module Klue
         attr_accessor :processed
 
         def initialize
-          @data = {}
-          @processed = false
+          klue_reset
         end
 
         def process(input: nil, input_file: nil, output_file: nil)
-          validate_input_arguments(input, input_file)
-          input_content = input_content(input, input_file)
+          klue_reset
+          klue_validate_input_arguments(input, input_file)
+          klue_input_content = klue_input_content(input, input_file)
 
           @processed = true
-          instance_eval(input_content)
+          instance_eval(klue_input_content)
 
-          write_output(output_file) if output_file
+          klue_write_output(output_file) if output_file
           data
         end
 
@@ -36,7 +36,7 @@ module Klue
           raise "You must call 'process' before using other methods" unless @processed
 
           key = method_name
-          value = process_args(args, block)
+          value = klue_process_args(args, block)
 
           if @data[key]
             @data[key] = [@data[key]] unless @data[key].is_a?(Array)
@@ -50,7 +50,7 @@ module Klue
           @processed || super
         end
 
-        def process_args(args, block)
+        def klue_process_args(args, block)
           positional_args = []
           named_args = {}
 
@@ -82,32 +82,32 @@ module Klue
 
         private
 
-        def validate_input_arguments(input, input_file)
+        def klue_reset
+          @data = {}
+          @processed = false
+        end
+
+        def klue_validate_input_arguments(input, input_file)
           raise ArgumentError, 'Either input or input_file must be provided' unless input || input_file
           raise ArgumentError, 'Both input and input_file cannot be provided' if input && input_file
         end
 
-        def input_content(input, input_file)
+        def klue_input_content(input, input_file)
           input_file ? File.read(input_file) : input
         end
 
-        def write_output(output_file)
-          output_path = get_output_path(output_file)
+        def klue_write_output(output_file)
+          output_path = klue_output_path(output_file)
           File.write(output_path, JSON.pretty_generate(data))
         end
 
-        def get_output_path(output_file)
+        def klue_output_path(output_file)
           if Pathname.new(output_file).absolute?
             output_file
           else
             File.join(File.dirname(output_file), File.basename(output_file))
           end
         end
-
-        # Convert to JSON
-        def to_json(*_args)
-          @data.to_json
-        end
       end
     end
   end

data/lib/klue/langcraft/dsl/klue_runner.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Klue
+  module Langcraft
+    module DSL
+      # KlueRunner handles the processing of DSL input data
+      # It manages the execution of various processors and the output of processed data
+      class KlueRunner
+        attr_reader :interpreter, :pipeline, :webhook
+
+        def initialize
+          @interpreter = Klue::Langcraft::DSL::Interpreter.new
+          @pipeline = Klue::Langcraft::DSL::ProcessDataPipeline.new(Klue::Langcraft::DSL::ProcessMatcher.new)
+          @webhook = Klue::Langcraft::DSL::Webhook.new
+        end
+
+        # Run the KlueRunner with the given input data
+        # @param input [String] The input data to process
+        # @param input_file [String] The input file to process (input data and file are mutually exclusive)
+        # @param basic_output_file [String] The output file to write the processed data, this file is before any processing
+        # @param enhanced_output_file [String] The output file to write the processed data, this file is after processing
+        def run(
+          input: nil,
+          input_file: nil,
+          basic_output_file: nil,
+          enhanced_output_file: nil,
+          webhook_url: nil,
+          log_level: :none
+        )
+          @log_level = log_level
+
+          log_info('Processing input')
+          data = interpreter.process(input: input, input_file: input_file, output_file: basic_output_file)
+          log_detailed('Interpreter output:', data)
+
+          log_info('Executing pipeline - enhance')
+          enhanced_data = pipeline.execute(data)
+          log_detailed('Enhanced output:', enhanced_data)
+
+          if enhanced_output_file
+            log_info("Writing enhanced output to file: #{enhanced_output_file}")
+            @pipeline.write_output(enhanced_data, enhanced_output_file)
+          end
+
+          if webhook_url
+            log_info("Delivering data to webhook: #{webhook_url}")
+            @webhook.deliver(webhook_url, enhanced_data)
+          end
+
+          log_info('Processing complete')
+        end
+
+        private
+
+        def log_info(message)
+          puts message if %i[info detailed].include?(@log_level)
+        end
+
+        def log_detailed(message, data)
+          return unless @log_level == :detailed
+
+          puts message
+          pp data
+        end
+      end
+    end
+  end
+end

data/lib/klue/langcraft/dsl/watcher.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'listen'
+
+module Klue
+  module Langcraft
+    module DSL
+      # Watcher class for monitoring file changes in specified directories.
+      # This class sets up a file system listener to watch for changes to files
+      # with specified extensions, and processes those files using a KlueRunner.
+      class Watcher
+        def initialize(directories, **options)
+          @directories = directories.map { |dir| File.expand_path(dir) }
+          @options = options
+          @klue_runner = Klue::Langcraft::DSL::KlueRunner.new
+          @extensions = options[:extensions] || ['.klue']
+        end
+
+        def start
+          listener = create_listener
+          log_watcher_info
+          listener.start
+          sleep
+        end
+
+        private
+
+        def create_listener
+          extension_regex = create_extension_regex
+          Listen.to(*@directories, only: extension_regex) do |modified, added, _removed|
+            process_changed_files(modified + added)
+          end
+        end
+
+        def create_extension_regex
+          Regexp.union(@extensions.map { |ext| /#{Regexp.escape(ext)}$/ })
+        end
+
+        def process_changed_files(files)
+          files.each { |file| process_file(file) }
+        end
+
+        def process_file(file)
+          log_info('Processing file', file)
+          options = create_file_options(file)
+          run_klue_runner(options)
+        rescue StandardError => e
+          log_error('Error processing file', "#{file}: #{e.message}")
+        end
+
+        def create_file_options(file)
+          options = @options.dup
+          options[:input_file] = file
+          options[:basic_output_file] = file.sub(/#{File.extname(file)}$/, '.json') if @options[:create_basic_json]
+          options[:enhanced_output_file] = file.sub(/#{File.extname(file)}$/, '.enhanced.json') if @options[:create_enhanced_json]
+          options
+        end
+
+        def run_klue_runner(options)
+          @klue_runner.run(
+            input_file: options[:input_file],
+            basic_output_file: options[:basic_output_file],
+            enhanced_output_file: options[:enhanced_output_file],
+            webhook_url: options[:webhook_url],
+            log_level: options[:log_level]
+          )
+        end
+
+        def log_watcher_info
+          log_info('Watching directories', @directories.join(', '))
+          log_info('Watching file extensions', @extensions.join(', '))
+          log_info('Create basic JSON', @options[:create_basic_json])
+          log_info('Create enhanced JSON', @options[:create_enhanced_json])
+          log_info('Webhook URL', @options[:webhook_url])
+          log_info('Log level', @options[:log_level])
+        end
+
+        def log_info(label, value)
+          puts "#{label.ljust(30)}: #{value}" if %i[info detailed].include?(@options[:log_level])
+        end
+
+        def log_error(label, value)
+          puts "#{label.ljust(30)}: #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/klue/langcraft/dsl/webhook.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Klue
+  module Langcraft
+    module DSL
+      # Webhook class for handling HTTP POST requests to specified URLs.
+      # This class is responsible for sending processed data to external services
+      # via webhooks, handling the delivery process, and logging the results.
+      class Webhook
+        def deliver(webhook_url, data)
+          klue_type = extract_klue_type(data)
+          uri = build_uri(webhook_url, klue_type)
+          response = send_request(uri, build_payload(klue_type, data))
+          log_response(response, uri)
+          response
+        end
+
+        private
+
+        def extract_klue_type(data)
+          data.keys.first.to_s
+        end
+
+        def build_uri(webhook_url, klue_type)
+          URI.parse("#{webhook_url}?klue-type=#{klue_type}")
+        end
+
+        def build_payload(klue_type, data)
+          { klue_type: klue_type, data: data }
+        end
+
+        def send_request(uri, payload)
+          http = Net::HTTP.new(uri.host, uri.port)
+          request = Net::HTTP::Post.new(uri.path, { 'Content-Type' => 'application/json' })
+          request.body = payload.to_json
+          http.request(request)
+        end
+
+        def log_response(response, uri)
+          puts "Response: #{response.code} - #{response.message}"
+          puts "Endpoint: #{uri}"
+          log_response_body(response)
+        end
+
+        def log_response_body(response)
+          body = JSON.parse(response.body)
+          puts "DSL Type: #{body['type']}"
+          # puts JSON.pretty_generate(body['data'])
+        end
+      end
+    end
+  end
+end

data/lib/klue/langcraft/version.rb

@@ -2,6 +2,6 @@
 
 module Klue
   module Langcraft
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
   end
 end

data/lib/klue/langcraft.rb

@@ -19,6 +19,9 @@ require 'klue/langcraft/dsl/processors/full_name_processor'
 require 'klue/langcraft/dsl/interpreter'
 require 'klue/langcraft/dsl/process_matcher'
 require 'klue/langcraft/dsl/process_data_pipeline'
+require 'klue/langcraft/dsl/webhook'
+require 'klue/langcraft/dsl/watcher'
+require 'klue/langcraft/dsl/klue_runner'
 
 require 'base_process'
 require 'process_file_collector'

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "klue-langcraft",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "klue-langcraft",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "devDependencies": {
         "@klueless-js/semantic-release-rubygem": "github:klueless-js/semantic-release-rubygem",
         "@semantic-release/changelog": "^6.0.3",

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klue-langcraft",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Domain Specific Language Crafting",
   "scripts": {
     "release": "semantic-release"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: klue-langcraft
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - David Cruwys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-10-25 00:00:00.000000000 Z
+date: 2024-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appydave-tools
@@ -62,6 +62,7 @@ files:
 - Rakefile
 - bin/console
 - bin/dsl_watcher.rb
+- bin/langcraft.rb
 - bin/setup
 - docs/dsl-class-diagram.md
 - docs/dsl-examples.md
@@ -84,12 +85,15 @@ files:
 - lib/dsl_process_data.rb
 - lib/klue/langcraft.rb
 - lib/klue/langcraft/dsl/interpreter.rb
+- lib/klue/langcraft/dsl/klue_runner.rb
 - lib/klue/langcraft/dsl/process_data_pipeline.rb
 - lib/klue/langcraft/dsl/process_matcher.rb
 - lib/klue/langcraft/dsl/processor_config.rb
 - lib/klue/langcraft/dsl/processors/file_collector_processor.rb
 - lib/klue/langcraft/dsl/processors/full_name_processor.rb
 - lib/klue/langcraft/dsl/processors/processor.rb
+- lib/klue/langcraft/dsl/watcher.rb
+- lib/klue/langcraft/dsl/webhook.rb
 - lib/klue/langcraft/tokenizer-old-needs-revisit/-brief.md
 - lib/klue/langcraft/tokenizer-old-needs-revisit/parser.rb
 - lib/klue/langcraft/tokenizer-old-needs-revisit/sample_usage.rb