glazed-oxidized 0.1.0

data/lib/glazed/oxidized/secret_substitution.rb

@@ -0,0 +1,105 @@
+# typed: strict
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: Apache-2.0
+
+require 'glazed/must'
+
+module Glazed
+  module Oxidized
+    # A substitution from a model's `cmd :secret` block, which hides secrets
+    # by replacing matches of a pattern. The secret is what the replacement
+    # drops from a match.
+    #
+    # @example
+    #   substitution = Glazed::Oxidized::SecretSubstitution.new(pattern: /^(snmp-server community) \S+/, replacement: '\\1 <hidden>')
+    #   match = substitution.pattern.match('snmp-server community public')
+    #   substitution.offsets(match) #=> 22...28
+    class SecretSubstitution
+      # Backreferences in a replacement, as String#sub expands them.
+      BACKREFERENCE = /\\(?:(\d)|k<(\w+)>|([&`'+\\]))/ #: Regexp
+
+      # @param pattern [Regexp] pattern the block substitutes
+      # @param replacement [String] replacement, with backreferences
+      #: (pattern: Regexp, replacement: String) -> void
+      def initialize(pattern:, replacement:)
+        @pattern = pattern #: Regexp
+        @replacement = replacement #: String
+      end
+
+      # @return [Regexp] pattern the block substitutes
+      #: Regexp
+      attr_reader :pattern
+      # @return [String] replacement, with backreferences
+      #: String
+      attr_reader :replacement
+
+      # Finds the text the replacement drops from a match: the match without
+      # the start and end it shares with its replacement, and without
+      # surrounding whitespace. A shared start or end never ends inside a word,
+      # so a secret beginning like the replacement is not partly kept.
+      #
+      # @param match [MatchData] a match of {pattern}
+      # @return [Range<Integer>, nil] offsets of the dropped text in the matched string, or nil when nothing is dropped
+      #: (MatchData match) -> Range[Integer]?
+      def offsets(match)
+        matched = match[0].to_s
+        replaced = expand(match)
+        head = shared_length(matched, replaced)
+        head -= 1 while head.positive? && word?(matched[head - 1]) && word?(matched[head])
+        tail = shared_length(matched[head..].to_s.reverse, replaced[head..].to_s.reverse)
+        tail -= 1 while tail.positive? && word?(matched[-tail - 1]) && word?(matched[-tail])
+        start = head
+        finish = matched.size - tail
+        start += 1 while start < finish && whitespace?(matched[start])
+        finish -= 1 while finish > start && whitespace?(matched[finish - 1])
+        return nil if start >= finish
+
+        origin = match.begin(0)
+        (origin + start)...(origin + finish)
+      end
+
+      # @param match [MatchData] a match of {pattern}
+      # @return [String] the replacement with its backreferences expanded
+      #: (MatchData match) -> String
+      private def expand(match)
+        replacement.gsub(BACKREFERENCE) do
+          reference = Must.expect(Regexp.last_match)
+          if (group = reference[1])
+            match[group.to_i].to_s
+          elsif (name = reference[2])
+            match[name].to_s
+          else
+            case reference[3]
+            when '&' then match[0].to_s
+            when '`' then match.pre_match
+            when "'" then match.post_match
+            when '+' then match.captures.compact.last.to_s
+            else '\\'
+            end
+          end
+        end
+      end
+
+      # @param left [String] a string
+      # @param right [String] another string
+      # @return [Integer] length of the start the strings share
+      #: (String left, String right) -> Integer
+      private def shared_length(left, right)
+        length = 0
+        length += 1 while length < left.size && length < right.size && left[length] == right[length]
+        length
+      end
+
+      # @param char [String, nil] a character
+      # @return [Boolean] whether it is a word character
+      #: (String? char) -> bool
+      private def word?(char) = char&.match?(/\w/) || false
+
+      # @param char [String, nil] a character
+      # @return [Boolean] whether it is whitespace
+      #: (String? char) -> bool
+      private def whitespace?(char) = char&.match?(/\s/) || false
+    end
+  end
+end

data/lib/glazed/oxidized/version.rb

@@ -0,0 +1,11 @@
+# typed: strict
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: Apache-2.0
+
+module Glazed
+  module Oxidized
+    # Gem version.
+    VERSION = '0.1.0' #: String
+  end
+end

data/lib/glazed/oxidized.rb

@@ -0,0 +1,93 @@
+# typed: strict
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: Apache-2.0
+
+require 'glazed'
+require 'glazed/dialects'
+require 'glazed/must'
+require 'glazed/oxidized/errors'
+require 'glazed/oxidized/model_box'
+require 'glazed/oxidized/model_dialect'
+require 'glazed/oxidized/version'
+
+module Glazed
+  # Runs Oxidized model files as glazed dialects. A node whose dialect is
+  # "oxidized_<model>" runs the model file `<model>.rb` found in {model_paths}.
+  #
+  # Each model is loaded into its own Ruby::Box, which needs RUBY_BOX=1 in the
+  # environment of the Ruby process.
+  #
+  # @example
+  #   require 'glazed/oxidized'
+  #   Glazed::Dialects.find('oxidized_aireos') #=> Glazed::Dialects::OxidizedAireos
+  module Oxidized
+    # Prefix of dialect names that run an Oxidized model.
+    DIALECT_PREFIX = 'oxidized_' #: String
+
+    @model_paths = nil #: Array[String]?
+    @lock = Mutex.new #: Thread::Mutex
+
+    class << self
+      # Directories searched for model files, in order. Defaults to Oxidized's
+      # own order: the model directory under $OXIDIZED_HOME (or
+      # ~/.config/oxidized), then the models of the installed oxidized gem.
+      #
+      # @return [Array<String>] directories, which callers may change
+      #: () -> Array[String]
+      def model_paths
+        @model_paths ||= default_model_paths
+      end
+
+      # @param paths [Array<String>] directories searched for model files
+      # @return [void]
+      #: (Array[String] paths) -> void
+      def model_paths=(paths)
+        @model_paths = paths
+      end
+
+      # @param name [String] model name, such as "ios"
+      # @return [String, nil] absolute path of the first model file by that name in {model_paths}
+      #: (String name) -> String?
+      def model_path(name)
+        return nil unless name.match?(/\A[a-z0-9_]+\z/)
+
+        model_paths.map { File.join(File.expand_path(it), "#{name}.rb") }.find { File.file?(it) }
+      end
+
+      # Builds the dialect running a model and registers it under
+      # {Dialects}, so later lookups find it without loading the model again.
+      #
+      # @param name [String] model name, such as "ios"
+      # @return [Class<ModelDialect>, nil] the dialect, or nil when no model file has the name
+      # @raise [UnavailableError] when Ruby::Box is not enabled
+      # @raise [ModelNotFound] when the file defines no model class by its name
+      #: (String name) -> singleton(ModelDialect)?
+      def dialect(name)
+        constant_name = "#{DIALECT_PREFIX}#{name}".split('_').map(&:capitalize).join
+        @lock.synchronize do
+          if Dialects.const_defined?(constant_name, false)
+            return Must.be_a(Dialects.const_get(constant_name, false), Class) #: as singleton(ModelDialect)
+          end
+
+          path = model_path(name) or return nil
+          dialect = ModelDialect.build(ModelBox.new(name:, path:))
+          Dialects.const_set(constant_name, dialect)
+          dialect
+        end
+      end
+
+      # @return [Array<String>] Oxidized's model directories
+      #: () -> Array[String]
+      private def default_model_paths
+        home = ENV.fetch('OXIDIZED_HOME') { File.join(Dir.home, '.config', 'oxidized') }
+        paths = [File.join(home, 'model')]
+        gem = Gem::Specification.find_all_by_name('oxidized').max_by(&:version)
+        paths << File.join(gem.gem_dir, 'lib', 'oxidized', 'model') if gem
+        paths
+      end
+    end
+
+    Dialects.add_resolver { |name| dialect(name.delete_prefix(DIALECT_PREFIX)) if name.start_with?(DIALECT_PREFIX) }
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: glazed-oxidized
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sorah Fukumori
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: glazed
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- her@sorah.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/glazed/oxidized.rb
+- lib/glazed/oxidized/bridge.rb
+- lib/glazed/oxidized/errors.rb
+- lib/glazed/oxidized/model_box.rb
+- lib/glazed/oxidized/model_dialect.rb
+- lib/glazed/oxidized/node_view.rb
+- lib/glazed/oxidized/prelude.rb
+- lib/glazed/oxidized/secret_substitution.rb
+- lib/glazed/oxidized/version.rb
+homepage: https://github.com/sorah/glazed
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/sorah/glazed
+  source_code_uri: https://github.com/sorah/glazed/tree/main/glazed-oxidized
+  changelog_uri: https://github.com/sorah/glazed/blob/main/glazed-oxidized/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Oxidized model compatibility layer for glazed
+test_files: []