sitedog_parser 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49947334cc7ee3ec9a5fae7622586f0ad834c515af3470beee348637742ab532
-  data.tar.gz: 352cfe07e7b0451ce0e06a5b816d8a4ff0b72e1c623fef8cce313860e3609db4
+  metadata.gz: 04e6beaed38d60a1269ed3f20b071f9576eb6c4c40142fbb65fdaa4bd3bac14f
+  data.tar.gz: acf60abb7739f59e4b5732f95286a4e14f386ceaf1ad7d9b971d1fabc3886a87
 SHA512:
-  metadata.gz: 2a9b6e77751102b746f4332f9b4d253800b37951512abb2b7df1db1df53662890d94cb41e4c2d4626e5bd563c14bd2349111fe6069db1f273e5ceea9d4d76be7
-  data.tar.gz: 97a48e91c2878bcce840907b92cbfc3986df3cf71a3d5b2e4541a083effb884ecac10f9b4c56334d0b5696a47f4db059006fb4d05fa4cccb33643ea6cb521c65
+  metadata.gz: 7825cb9106d8861d3084ca9eee9f0c52d0dfbfbc409a0a2320cd89e1487a8ed8334fdf1e1d629ab6b65d25da3e514f4dfdf059be88bdd2bad23f6d08e8ca2b63
+  data.tar.gz: ccad1201ba56171fd64a9869dfa538bd24ba6cc44feb0fc52f40c17962a6c582dd1589c375226ae21f289dabe67097c70eb92ad807b161ac6e40ff10b3133a55

data/README.md

@@ -4,29 +4,13 @@ A library for parsing and classifying web services from YAML files into structur
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
 ```ruby
 gem 'sitedog_parser'
 ```
 
-Then execute:
-
-```bash
-$ bundle install
-```
-
-Or install it yourself:
-
-```bash
-$ gem install sitedog_parser
-```
-
 ## Usage
 
-### High-Level Interface
-
-The easiest way to use SitedogParser is through its high-level interface:
+### Basic Usage
 
 ```ruby
 require 'sitedog_parser'
@@ -34,256 +18,94 @@ require 'sitedog_parser'
 # Parse from a YAML file
 parsed_data = SitedogParser::Parser.parse_file('data.yml')
 
-# Or parse from a hash (if you already loaded the YAML)
-yaml_data = YAML.load_file('data.yml', symbolize_names: true)
-parsed_data = SitedogParser::Parser.parse(yaml_data)
-
-# Get all services of a specific type across all domains
-all_hosting_services = SitedogParser::Parser.get_services_by_type(parsed_data, :hosting)
-all_hosting_services.each do |service|
-  puts "Hosting service: #{service.service}, URL: #{service.url}"
-end
-
-# Get all domain names
-domain_names = SitedogParser::Parser.get_domain_names(parsed_data)
-puts "Found domains: #{domain_names.join(', ')}"
-
 # Working with specific domain's services
 domain_services = parsed_data['example.com']
-if domain_services[:dns]
-  puts "DNS service: #{domain_services[:dns].first.service}"
+if domain_services[:hosting]
+  puts "Hosting: #{domain_services[:hosting].first.service}"
+  puts "URL: #{domain_services[:hosting].first.url}"
 end
 ```
 
-### Working with Simple Fields
+### Simple Fields
 
-You can specify which fields should be treated as simple string values, not as services:
+You can specify which fields should be treated as simple values:
 
 ```ruby
-# Define which fields should remain as simple strings (not wrapped in Service objects)
-simple_fields = [:project, :role, :environment, :registry, :bought_at]
+# Define simple fields
+simple_fields = [:project, :role, :environment, :registry]
 
 # Parse with simple fields
 parsed_data = SitedogParser::Parser.parse(yaml_data, simple_fields: simple_fields)
 
-# Now you can access these fields directly as strings
-domain_services = parsed_data['example.com']
-if domain_services[:project]
-  puts "Project: #{domain_services[:project]}"  # This is a string, not a Service object
-end
-
 # Find domains with a specific field value
-domains_with_production = SitedogParser::Parser.get_domains_by_field_value(parsed_data, :environment, 'production')
-puts "Production domains: #{domains_with_production.join(', ')}"
+production_domains = SitedogParser::Parser.get_domains_by_field_value(parsed_data, :environment, 'production')
 ```
 
-### Finding Dictionary Candidates
-
-You can use the DictionaryAnalyzer to find services that might be missing from your dictionary:
+### Export to JSON
 
 ```ruby
-require 'sitedog_parser'
-require_relative 'lib/dictionary_analyzer'
+# Standard output
+json_data = SitedogParser::Parser.to_json('services.yml')
 
-# Parse your data first
-parsed_data = SitedogParser::Parser.parse_file('data.yml')
+# Or via command line:
+# $ sitedog_cli services.yml > services.json
 
-# Find candidates for the dictionary (services with name but no URL)
-candidates = SitedogParser::DictionaryAnalyzer.find_dictionary_candidates(parsed_data)
-
-# Generate a report
-report = SitedogParser::DictionaryAnalyzer.report(parsed_data)
-puts report
-
-# Or use the provided script
-# bin/analyze_dictionary data.yml
+# Compact JSON for inner objects
+# $ sitedog_cli -C services.yml > services.json
 ```
 
-The report will show:
-1. A list of services that are missing from the dictionary
-2. How many domains use each service
-3. In which context (service type) each service is used
-4. A YAML template ready to be added to your dictionary
-
-### Example: Processing a YAML Configuration
-
-Input YAML file (`services.yml`):
-
-```yaml
-example.com:
-  hosting: https://aws.amazon.com
-  dns:
-    service: cloudflare
-    url: https://cloudflare.com
-  registrar: namecheap
-  ssl: letsencrypt
-  repo: https://github.com/example/repo
-
-another-site.org:
-  hosting:
-    service: digitalocean
-    url: https://digitalocean.com
-  cdn: https://cloudfront.aws.amazon.com
-  dns: https://domains.google.com
-```
-
-Processing this file:
-
-```ruby
-require 'sitedog_parser'
-
-# Parse the file
-data = SitedogParser::Parser.parse_file('services.yml')
-
-# Get all domains
-puts "Domains: #{SitedogParser::Parser.get_domain_names(data).join(', ')}"
+### JSON Structure Example
 
-# Get all hosting services
-hosting_services = SitedogParser::Parser.get_services_by_type(data, :hosting)
-puts "\nHosting services:"
-hosting_services.each do |service|
-  puts "- #{service.service}: #{service.url}"
-end
-
-# Get all DNS services
-dns_services = SitedogParser::Parser.get_services_by_type(data, :dns)
-puts "\nDNS services:"
-dns_services.each do |service|
-  puts "- #{service.service}: #{service.url}"
-end
-
-# Access a specific domain's services
-puts "\nServices for example.com:"
-example_services = data['example.com']
-example_services.each do |type, services|
-  puts "#{type}: #{services.first.service}"
-end
-```
-
-Output:
-```
-Domains: example.com, another-site.org
-
-Hosting services:
-- Amazon Web Services: https://aws.amazon.com
-- Digitalocean: https://digitalocean.com
-
-DNS services:
-- Cloudflare: https://cloudflare.com
-- Domains: https://domains.google.com
-
-Services for example.com:
-hosting: Amazon Web Services
-dns: Cloudflare
-registrar: Namecheap
-ssl: Letsencrypt
-repo: Github
+```json
+{
+  "example.com": {
+    "hosting": [{"service":"Amazon Web Services","url":"https://aws.amazon.com"}],
+    "dns": [{"service":"Cloudflare","url":"https://cloudflare.com"}],
+    "registrar": [{"service":"Namecheap","url":"https://namecheap.com"}]
+  }
+}
 ```
 
-### Service Object Structure
-
-Each service object has the following structure:
+### Service Object
 
 ```ruby
-# Service fields
 service.service  # Name of the service (capitalized string)
 service.url      # URL of the service (string or nil)
 service.children # Child services (array of Service objects, empty if none)
 ```
 
-### Processing Different Data Formats
-
-SitedogParser's strength is in normalizing different data formats into a consistent structure. Here are examples showing how various input formats are handled:
-
-#### 1. Simple URL string
-```ruby
-# Input
-data = "https://github.com/username/repo"
+### Supported Data Formats
 
-# Output
-service = ServiceFactory.create(data)
-service.service  # => "Github"
-service.url      # => "https://github.com"
-service.children # => []
-```
+The library handles various data formats:
 
-#### 2. Service name string
-```ruby
-# Input
-data = "GitHub"
+1. **URL strings**: `"https://github.com/username/repo"` → GitHub service
+2. **Service names**: `"GitHub"` → GitHub service with URL
+3. **Hashes with service and URL**: `{service: "Github", url: "https://github.com/repo"}`
+4. **Nested hashes** with service types
+5. **Hashes with URLs** as values
 
-# Output
-service = ServiceFactory.create(data)
-service.service  # => "GitHub"
-service.url      # => "https://github.com"
-service.children # => []
-```
+### Dictionary Analysis
 
-#### 3. Hash with service and URL
 ```ruby
-# Input
-data = {
-  service: "Github",
-  url: "https://github.com/username/repo"
-}
+# Find candidates for the dictionary (services with name but no URL)
+candidates = SitedogParser::DictionaryAnalyzer.find_dictionary_candidates(parsed_data)
 
-# Output
-service = ServiceFactory.create(data)
-service.service  # => "Github"
-service.url      # => "https://github.com/username/repo"
-service.children # => []
+# Generate a report
+report = SitedogParser::DictionaryAnalyzer.report(parsed_data)
 ```
 
-#### 4. Nested hash with service types
-```ruby
-# Input
-data = {
-  dns: {
-    service: "route53",
-    url: "https://console.aws.amazon.com/route53"
-  },
-  registrar: {
-    service: "namecheap",
-    url: "https://namecheap.com"
-  }
-}
+### Command Line Options
 
-# Output
-service = ServiceFactory.create(data)
-service.service           # => "Unknown"
-service.children.size     # => 2
-service.children[0].service # => "Route53"
-service.children[0].url     # => "https://console.aws.amazon.com/route53"
-service.children[1].service # => "Namecheap"
-service.children[1].url     # => "https://namecheap.com"
 ```
-
-#### 5. Hash with URLs
-```ruby
-# Input
-data = {
-  hosting: "https://aws.amazon.com",
-  cdn: "https://cloudflare.com"
-}
-
-# Output
-service = ServiceFactory.create(data)
-service.service           # => "Unknown"
-service.children.size     # => 2
-service.children[0].service # => "Hosting"
-service.children[0].url     # => "https://aws.amazon.com"
-service.children[1].service # => "Cdn"
-service.children[1].url     # => "https://cloudflare.com"
+$ sitedog_cli --help
+Usage: sitedog_cli [options] <path_to_yaml_file> [output_file]
+    -d, --debug                 Enable debug output
+    -c, --compact               Compact JSON without formatting
+    -C, --compact-children      Formatted JSON with compact inner objects
+    -q, --quiet                 Suppress non-error messages
+    -h, --help                  Show this help message
 ```
 
-## Development and Contribution
-
-1. Fork the repository
-2. Create a branch for your changes (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add new feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a Pull Request
-
 ## License
 
-This gem is available under the MIT license. See the [LICENSE.txt](LICENSE.txt) file for details.
+MIT

data/bin/analyze_dictionary

@@ -42,7 +42,7 @@ begin
   end
 
   # Определяем простые поля, которые не должны рассматриваться как сервисы
-  simple_fields = [:project, :role, :environment, :registry, :bought_at]
+  simple_fields = [:project, :role, :environment, :registry]
 
   # Анализируем данные через наш интерфейс Parser
   data = SitedogParser::Parser.parse(sites_data, simple_fields: simple_fields, dictionary_path: dictionary_path)

data/bin/sitedog_cli

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'sitedog_parser'
+require 'optparse'
+require 'logger'
+
+# Set default options
+options = {
+  debug: false,
+  pretty: true,
+  compact_children: false,
+  output: nil,
+  log_level: Logger::INFO
+}
+
+# Create logger
+logger = Logger.new(STDOUT)
+logger.formatter = proc do |severity, datetime, progname, msg|
+  "#{msg}\n"
+end
+
+# Command line options parser
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: sitedog_cli [options] <path_to_yaml_file> [output_file]"
+
+  opts.on("-d", "--debug", "Enable debug output") do
+    options[:debug] = true
+    options[:log_level] = Logger::DEBUG
+  end
+
+  opts.on("-c", "--compact", "Output compact JSON (without pretty formatting)") do
+    options[:pretty] = false
+  end
+
+  opts.on("--compact-children", "-C", "Format JSON with compact inner objects (one line per service)") do
+    options[:compact_children] = true
+  end
+
+  opts.on("-q", "--quiet", "Suppress non-error messages") do
+    options[:log_level] = Logger::ERROR
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+end
+
+# Parse options
+option_parser.parse!(ARGV)
+
+# Set logging level
+logger.level = options[:log_level]
+
+# Check command line arguments
+if ARGV.empty? || ARGV.size < 1 || ARGV.size > 2
+  logger.error option_parser.help
+  exit 1
+end
+
+file_path = ARGV[0]
+output_path = ARGV[1]
+
+# Check if input file exists
+unless File.exist?(file_path)
+  logger.error "Error: File '#{file_path}' not found."
+  exit 1
+end
+
+# Redirect STDERR to hide debug output if not in debug mode
+unless options[:debug]
+  original_stderr = $stderr.dup
+  $stderr.reopen(File.open(File::NULL, 'w'))
+end
+
+# Format JSON with inner objects on a single line
+def compact_json_generate(data)
+  # Clone data to avoid modifying the original
+  formatted_data = Marshal.load(Marshal.dump(data))
+
+  # Process each domain
+  formatted_data.each do |domain_key, services|
+    # For each service type
+    services.each do |service_type, service_array|
+      if service_array.is_a?(Array)
+        # Convert service array to compact format
+        services[service_type] = service_array.map do |service_obj|
+          # Remove empty children arrays for compactness
+          if service_obj['children'] && service_obj['children'].empty?
+            service_obj.delete('children')
+          end
+          service_obj
+        end
+      end
+    end
+  end
+
+  # Convert to JSON with indentation at top level, but compact inner objects
+  output = "{\n"
+
+  formatted_data.each_with_index do |(domain, services), domain_index|
+    output << "  \"#{domain}\": {\n"
+
+    services.keys.sort.each_with_index do |service_type, service_index|
+      service_data = services[service_type]
+
+      # Start line with service type
+      output << "    \"#{service_type}\": "
+
+      # Special formatting for service arrays - on a single line
+      if service_data.is_a?(Array)
+        items = service_data.map { |item| JSON.generate(item) }.join(",")
+        output << "[#{items}]"
+      else
+        # For non-arrays use standard JSON.generate
+        output << JSON.generate(service_data)
+      end
+
+      # Add comma for all elements except the last one
+      output << (service_index < services.keys.size - 1 ? ",\n" : "\n")
+    end
+
+    output << "  }"
+    output << (domain_index < formatted_data.size - 1 ? ",\n" : "\n")
+  end
+
+  output << "}"
+  output
+end
+
+begin
+  logger.debug "Processing file: #{file_path}"
+
+  # Convert YAML to JSON
+  data = SitedogParser::Parser.to_hash(file_path, { logger: logger })
+  logger.debug "Data converted to hash"
+
+  # Convert to JSON based on formatting options
+  json_data = if options[:compact_children]
+                logger.debug "Generating JSON with compact inner objects"
+                compact_json_generate(data)
+              elsif options[:pretty]
+                logger.debug "Generating pretty JSON"
+                JSON.pretty_generate(data)
+              else
+                logger.debug "Generating compact JSON"
+                JSON.generate(data)
+              end
+
+  # If output file is specified, save result to it
+  if output_path
+    logger.debug "Saving to file: #{output_path}"
+    File.write(output_path, json_data)
+    logger.info "JSON data successfully saved to '#{output_path}'."
+  else
+    # Otherwise print JSON to screen
+    # Use puts directly for JSON output to avoid logger prefixes
+    puts json_data
+  end
+
+rescue => e
+  # Restore STDERR for error messages
+  $stderr.reopen(original_stderr) unless options[:debug]
+
+  logger.error "Error processing file: #{e.message}"
+  logger.debug e.backtrace.join("\n") if options[:debug]
+  exit 1
+ensure
+  # Restore STDERR
+  $stderr.reopen(original_stderr) unless options[:debug]
+end

data/lib/service.rb

@@ -1,11 +1,16 @@
-class Service < Data.define(:service, :url, :children)
-  def initialize(service:, url: nil, children: [])
+class Service < Data.define(:service, :url, :children, :image_url)
+  def initialize(service:, url: nil, children: [], image_url: nil)
     raise ArgumentError, "Service cannot be empty" if service.nil? || service.empty?
 
     service => String
     url => String if url
     children => Array if children
+    image_url => String if image_url
 
     super
   end
+
+  def has_children?
+    !children.empty?
+  end
 end

data/lib/service_factory.rb

@@ -2,6 +2,7 @@ require 'pry'
 require_relative 'url_checker'
 require_relative 'dictionary'
 require_relative 'service'
+require 'logger'
 
 # Factory for creating Service objects from different data formats
 class ServiceFactory
@@ -10,19 +11,26 @@ class ServiceFactory
   # @param data [String, Hash, Array] data for creating service
   # @param service_type [Symbol] service type (used as fallback)
   # @param dictionary_path [String, nil] path to the dictionary file (optional)
+  # @param options [Hash] дополнительные опции
+  # @option options [Logger] :logger логгер для вывода сообщений
   # @return [Service] created service object
-  def self.create(data, service_type = nil, dictionary_path = nil)
+  def self.create(data, service_type = nil, dictionary_path = nil, options = {})
+    # Получаем логгер из опций или создаем пустой логгер, пишущий в nil
+    logger = options[:logger] || Logger.new(nil)
+
     # Check for nil
     return nil if data.nil?
 
     slug = nil
     url = nil
     dictionary = Dictionary.new(dictionary_path)
+    dict_entry = nil
 
     case data
     in String if UrlChecker.url_like?(data) # url
       url = UrlChecker.normalize_url(data)
-      slug = dictionary.match(url)&.dig('name')
+      dict_entry = dictionary.match(url)
+      slug = dict_entry&.dig('name')
 
       # If not found in dictionary and service_type exists, use it
       if slug.nil? && service_type
@@ -32,17 +40,26 @@ class ServiceFactory
         slug = UrlChecker.extract_name(url) if slug.nil?
       end
 
-      puts "url: #{slug} <- #{url}"
+      logger.debug "url: #{slug} <- #{url}"
     in String if !UrlChecker.url_like?(data) # slug
       slug = data
-      url = dictionary.lookup(slug)&.dig('url')
-      puts "slug: #{slug} -> #{url}"
+      dict_entry = dictionary.lookup(slug)
+
+      # Если нашли запись в словаре, используем её имя
+      if dict_entry && dict_entry['name']
+        slug = dict_entry['name']
+      end
+
+      url = dict_entry&.dig('url')
+      logger.debug "slug: #{slug} -> #{url}"
     in { service: String => service_slug, url: String => service_url }
       slug = service_slug.to_s.capitalize
       url = service_url
-      puts "hash: #{slug} + #{url}"
+      # Поиск в словаре после получения slug
+      dict_entry = dictionary.lookup(slug)
+      logger.debug "hash: #{slug} + #{url}"
     in Hash
-      puts "hash: #{data}"
+      logger.debug "hash: #{data}"
 
       # Protection from nil values in key fields
       if (data.key?(:service) || data.key?("service")) &&
@@ -52,12 +69,35 @@ class ServiceFactory
 
       # 1. Check if hash contains only URL-like strings (list of services)
       if data.values.all? { |v| v.is_a?(String) && UrlChecker.url_like?(v) }
-        puts "hash with services: #{data.keys.join(', ')}"
+        logger.debug "hash with services: #{data.keys.join(', ')}"
         # Create array of child services
         children = []
         data.each do |key, url_value|
           service_name = key.to_s
-          child_service = Service.new(service: service_name.capitalize, url: url_value)
+          # Первый приоритет - поиск в словаре по URL
+          child_dict_entry = dictionary.match(url_value)
+
+          if child_dict_entry && child_dict_entry['name']
+            # Если нашли запись в словаре по URL, используем её имя вместо ключа
+            service_name = child_dict_entry['name']
+          else
+            # Если записи в словаре нет по URL, ищем по имени
+            key_dict_entry = dictionary.lookup(service_name)
+            if key_dict_entry && key_dict_entry['name']
+              service_name = key_dict_entry['name']
+            else
+              # Если не нашли в словаре ни по URL, ни по имени, капитализируем исходное имя
+              service_name = service_name.capitalize
+            end
+          end
+
+          child_image_url = child_dict_entry&.dig('image_url')
+
+          child_service = Service.new(
+            service: service_name,
+            url: url_value,
+            image_url: child_image_url
+          )
           children << child_service
         end
 
@@ -79,7 +119,15 @@ class ServiceFactory
         url_key = data.key?(:url) ? :url : "url"
         url_value = data[url_key]
 
-        return Service.new(service: service_name.capitalize, url: url_value)
+        # Ищем в словаре
+        service_dict_entry = dictionary.lookup(service_name) || dictionary.match(url_value)
+        service_image_url = service_dict_entry&.dig('image_url')
+
+        return Service.new(
+          service: service_name.capitalize,
+          url: url_value,
+          image_url: service_image_url
+        )
       end
 
       # 3. Process nested hashes
@@ -98,13 +146,28 @@ class ServiceFactory
             url_key = value.key?(:url) ? :url : "url"
             url_value = value[url_key]
 
-            child = Service.new(service: service_name.capitalize, url: url_value)
+            # Ищем в словаре
+            nested_dict_entry = dictionary.lookup(service_name) || dictionary.match(url_value)
+            nested_image_url = nested_dict_entry&.dig('image_url')
+
+            child = Service.new(
+              service: service_name.capitalize,
+              url: url_value,
+              image_url: nested_image_url
+            )
           # 3.2 If value has hash with only URL-like values
           elsif value.values.all? { |v| v.is_a?(String) && UrlChecker.url_like?(v) }
             child_children = []
 
             value.each do |sub_key, url_value|
-              child_children << Service.new(service: sub_key.to_s.capitalize, url: url_value)
+              sub_dict_entry = dictionary.lookup(sub_key.to_s) || dictionary.match(url_value)
+              sub_image_url = sub_dict_entry&.dig('image_url')
+
+              child_children << Service.new(
+                service: sub_key.to_s.capitalize,
+                url: url_value,
+                image_url: sub_image_url
+              )
             end
 
             child = Service.new(service: key.to_s, children: child_children)
@@ -120,7 +183,14 @@ class ServiceFactory
               value.each do |sub_key, sub_value|
                 if sub_value.is_a?(String) && UrlChecker.url_like?(sub_value)
                   has_urls = true
-                  child_children << Service.new(service: sub_key.to_s.capitalize, url: sub_value)
+                  sub_dict_entry = dictionary.lookup(sub_key.to_s) || dictionary.match(sub_value)
+                  sub_image_url = sub_dict_entry&.dig('image_url')
+
+                  child_children << Service.new(
+                    service: sub_key.to_s.capitalize,
+                    url: sub_value,
+                    image_url: sub_image_url
+                  )
                 end
               end
 
@@ -129,7 +199,14 @@ class ServiceFactory
           end
         # 3.4 If the value is a URL string
         elsif value.is_a?(String) && UrlChecker.url_like?(value)
-          child = Service.new(service: key.to_s.capitalize, url: value)
+          url_dict_entry = dictionary.match(value)
+          url_image_url = url_dict_entry&.dig('image_url')
+
+          child = Service.new(
+            service: key.to_s.capitalize,
+            url: value,
+            image_url: url_image_url
+          )
         end
 
         children << child if child
@@ -146,7 +223,7 @@ class ServiceFactory
         return Service.new(service: "Unknown", children: children)
       end
     in Array
-      puts "array: #{data}"
+      logger.debug "array: #{data}"
 
       # Create services from array elements
       children = data.map { |item| create(item, service_type, dictionary_path) }.compact
@@ -169,13 +246,17 @@ class ServiceFactory
 
     # Create service with collected data
     if slug
-      Service.new(service: slug, url: url)
+      # Получаем URL изображения из записи словаря, если она есть
+      image_url = dict_entry&.dig('image_url')
+
+      # Создаем сервис со всеми данными сразу
+      Service.new(service: slug, url: url, image_url: image_url)
     else
       nil
     end
   rescue => e
-    puts "Error creating service: #{e.message}"
-    puts "Data: #{data.inspect}"
+    logger.error "Error creating service: #{e.message}"
+    logger.error "Data: #{data.inspect}"
     return nil
   end
 end

data/lib/sitedog_parser/version.rb

@@ -1,3 +1,3 @@
 module SitedogParser
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

data/lib/sitedog_parser.rb

@@ -1,5 +1,7 @@
 require "sitedog_parser/version"
 require 'yaml'
+require 'date'
+require 'json'
 
 require_relative "service"
 require_relative "dictionary"
@@ -20,10 +22,12 @@ module SitedogParser
     # @param symbolize_names [Boolean] whether to symbolize keys in the YAML file
     # @param simple_fields [Array<Symbol>] fields that should remain as simple strings without service wrapping
     # @param dictionary_path [String, nil] path to the dictionary file (optional)
+    # @param options [Hash] дополнительные опции
+    # @option options [Logger] :logger логгер для вывода сообщений
     # @return [Hash] hash containing parsed services by type and domain
-    def self.parse_file(file_path, symbolize_names: true, simple_fields: DEFAULT_SIMPLE_FIELDS, dictionary_path: nil)
+    def self.parse_file(file_path, symbolize_names: true, simple_fields: DEFAULT_SIMPLE_FIELDS, dictionary_path: nil, options: {})
       yaml = YAML.load_file(file_path, symbolize_names: symbolize_names)
-      parse(yaml, simple_fields: simple_fields, dictionary_path: dictionary_path)
+      parse(yaml, simple_fields: simple_fields, dictionary_path: dictionary_path, options: options)
     end
 
     # Parse YAML data and convert it to structured Ruby objects
@@ -31,22 +35,38 @@ module SitedogParser
     # @param yaml [Hash] YAML data as a hash
     # @param simple_fields [Array<Symbol>] fields that should remain as simple strings without service wrapping
     # @param dictionary_path [String, nil] path to the dictionary file (optional)
+    # @param options [Hash] дополнительные опции
+    # @option options [Logger] :logger логгер для вывода сообщений
     # @return [Hash] hash containing parsed services by type and domain
-    def self.parse(yaml, simple_fields: DEFAULT_SIMPLE_FIELDS, dictionary_path: nil)
+    def self.parse(yaml, simple_fields: DEFAULT_SIMPLE_FIELDS, dictionary_path: nil, options: {})
       result = {}
+      logger = options[:logger]
 
       yaml.each do |domain_name, items|
         services = {}
 
         # Process each service type and its data
         items.each do |service_type, data|
-          # Проверяем, является ли это поле "простым" (не сервисом)
-          if simple_fields.include?(service_type)
-            # Для простых полей просто сохраняем значение без оборачивания в сервис
-            services[service_type] = data
+          # Проверяем, является ли это поле "простым", имеет суффикс _at, или данные - экземпляр DateTime
+          if simple_fields.include?(service_type) || service_type.to_s.end_with?('_at') || data.is_a?(DateTime)
+            # Если данные уже DateTime, сохраняем как есть
+            if data.is_a?(DateTime)
+              services[service_type] = data
+            # Для полей _at пробуем преобразовать строку в DateTime
+            elsif service_type.to_s.end_with?('_at') && data.is_a?(String)
+              begin
+                services[service_type] = DateTime.parse(data)
+              rescue Date::Error
+                # Если не удалось преобразовать, оставляем как строку
+                services[service_type] = data
+              end
+            else
+              # Для обычных простых полей просто сохраняем значение
+              services[service_type] = data
+            end
           else
             # Для обычных полей создаем сервис
-            service = ServiceFactory.create(data, service_type, dictionary_path)
+            service = ServiceFactory.create(data, service_type, dictionary_path, options)
 
             if service
               services[service_type] ||= []
@@ -62,47 +82,51 @@ module SitedogParser
       result
     end
 
-    # Get all services of a specific type from parsed data
-    #
-    # @param parsed_data [Hash] data returned by parse or parse_file
-    # @param service_type [Symbol] type of service to extract
-    # @return [Array] array of services of the specified type
-    def self.get_services_by_type(parsed_data, service_type)
-      result = []
-
-      parsed_data.each do |_domain_name, services|
-        if services[service_type] && services[service_type].is_a?(Array)
-          result.concat(services[service_type])
+    # Преобразует YAML файл в хеш, где объекты Service преобразуются в хеши
+    # @param file_path [String] путь к YAML файлу
+    # @param options [Hash] дополнительные опции
+    # @option options [Logger] :logger логгер для вывода сообщений
+    # @return [Hash] хеш с сервисами
+    def self.to_hash(file_path, options = {})
+      data = parse_file(file_path, options: options)
+
+      # Преобразуем объекты Service в хеши
+      result = {}
+
+      data.each do |domain, services|
+        domain_key = domain.to_sym  # Преобразуем ключи доменов в символы
+        result[domain_key] = {}
+
+        services.each do |service_type, service_data|
+          service_type_key = service_type.to_sym  # Преобразуем ключи типов сервисов в символы
+
+          if service_data.is_a?(Array) && service_data.first.is_a?(Service)
+            # Преобразуем массив сервисов в массив хешей
+            result[domain_key][service_type_key] = service_data.map do |service|
+              {
+                'service' => service.service,
+                'url' => service.url,
+                'children' => service.children.map { |child| {'service' => child.service, 'url' => child.url} }
+              }
+            end
+          else
+            # Сохраняем простые поля как есть
+            result[domain_key][service_type_key] = service_data
+          end
         end
       end
 
       result
     end
 
-    # Get domain names from parsed data
+    # Преобразует данные из YAML файла в JSON формат
     #
-    # @param parsed_data [Hash] data returned by parse or parse_file
-    # @return [Array] array of domain names
-    def self.get_domain_names(parsed_data)
-      parsed_data.keys
-    end
-
-    # Get domains with a specific simple field value
-    #
-    # @param parsed_data [Hash] data returned by parse or parse_file
-    # @param field [Symbol] simple field to filter by
-    # @param value [String] value to match
-    # @return [Array] array of domain names that have the specified field value
-    def self.get_domains_by_field_value(parsed_data, field, value)
-      result = []
-
-      parsed_data.each do |domain_name, services|
-        if services[field] == value
-          result << domain_name
-        end
-      end
-
-      result
+    # @param file_path [String] путь к YAML файлу
+    # @param options [Hash] дополнительные опции
+    # @option options [Logger] :logger логгер для вывода сообщений
+    # @return [String] форматированная JSON строка
+    def self.to_json(file_path, options = {})
+      JSON.pretty_generate(to_hash(file_path, options))
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sitedog_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ivan Nemytchenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-15 00:00:00.000000000 Z
+date: 2025-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: minitest-power_assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -99,13 +113,14 @@ description: A library for parsing and classifying web services, hosting, and do
 email:
 - nemytchenko@gmail.com
 executables:
-- analyze_dictionary
+- sitedog_cli
 extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - README.md
 - bin/analyze_dictionary
+- bin/sitedog_cli
 - lib/data_structures.rb
 - lib/dictionary.rb
 - lib/dictionary_analyzer.rb