regex_generator 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d741dba07900c3b2364e317a4929a286cbefc3951218ec3878c08a695233b290
-  data.tar.gz: 80d263d8957320e7deac43b1b72a41891032c7660f4102bb435faee009fe706f
+  metadata.gz: 481f895706d869e948bda4786af67e5c12940228c50cd53f33b7d2f84eb4a0f1
+  data.tar.gz: 847974b444d2a2d217fc042144e625c60c297dec1dbfcf60bc692c0b73e985e2
 SHA512:
-  metadata.gz: 2de6cc1cce3b2a96a0aad9cd859460dfbbcf8ef7628456a71ec1a106cfe09fa889baf59bdb46e9426880c6a6f9edd8168032715b47da87754f058e2eba2bd1a8
-  data.tar.gz: af1ca8dfe14b9531dd69862a306f189904cc0f998a76f0b4b8e12333f18ad6e8d696be67b28ff9882af73b261c45533933d256ad8066437d3f52e513dabadca6
+  metadata.gz: d7f8c8af1fb62b699fe599431e83f568fe51ea752feb1749c933c876ff76e4a7c16e8e16aeb3467add14eb9aac6f63c07984f6ad4c849a64b01beeff36467284
+  data.tar.gz: 9b1038527f6f696146eccbba4f9b4abc1a17e0c201e7d35d5d03bca8b971f80660c52509375481efe62666efc491f1dde101ead3f2368ffa2bc03f73cc14eb38

data/Gemfile

@@ -2,7 +2,6 @@ source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
-# Specify your gem's dependencies in regex_generator.gemspec
 gemspec
 
 gem 'byebug'

data/lib/regex_generator.rb

@@ -2,12 +2,13 @@ require 'regex_generator/version'
 require 'byebug'
 require 'regex_generator/generator'
 require 'regex_generator/characters_recognizer'
+require 'regex_generator/target'
 require 'regex_generator/exceptions'
 
 module RegexGenerator
   # Generates regex by text and target text
   #
-  # @param target [String] what you want to find
+  # @param target [String, Integer, Float, Hash] what you want to find
   # @param text [String] source text
   # @param options [Hash] options to generate regex with
   # @option options [true, false] :exact_target to generate regex

data/lib/regex_generator/characters_recognizer.rb

@@ -20,6 +20,7 @@ module RegexGenerator
           res_pattern = escaped_char
           res_pattern = pattern.source if (char.eql?(escaped_char) &&
             !options[:self_recognition]&.include?(escaped_char)) || char[/\s/]
+
           break result << res_pattern
         end
       end

data/lib/regex_generator/generator.rb

@@ -10,14 +10,15 @@ module RegexGenerator
     #   itself
     def initialize(target, text, options = {})
       @text = text
-      @target = target_to_s(target)
+      @target = RegexGenerator::Target.new(target)
+      @target_str = @target.to_s
       @options = options
     end
 
     # @return [Regexp]
     # @raise [TargetNotFoundError] if target text was not found in the text
     def generate
-      raise RegexGenerator::TargetNotFoundError unless target_present?
+      raise RegexGenerator::TargetNotFoundError unless @target.present?(@text)
 
       string_regex_chars = recognize_text(cut_nearest_text, options)
       string_patterns_array = slice_to_identicals(string_regex_chars)
@@ -31,17 +32,20 @@ module RegexGenerator
     # Cuts nearest to target, text from the start of the string
     def cut_nearest_text
       start_pattern = @text[/\n/] ? /\n/ : /^/
-      if @target.is_a? Hash
-        target_regex = /(?:#{escaped_target.join('|')})/
-        text_regex_str = (1..@target.count).map do |step|
+
+      if @target.kind_of? Hash
+        target_regex = /(?:#{@target.escape.join('|')})/
+        text_regex_str = (1..@target_str.count).map do |step|
           all = step.eql?(1) ? '.' : '[\w\W]'
           "#{all}+?#{target_regex}"
         end.join
         text_regex = Regexp.new "#{start_pattern}#{text_regex_str}"
-        @text[text_regex]
-      else
-        @text[/[\w\W]*(#{start_pattern}[\w\W]+?)#{Regexp.escape(@target)}/, 1]
+
+        return @text[text_regex]
       end
+
+      regex = /[\w\W]*(#{start_pattern}[\w\W]+?)#{Regexp.escape(@target_str)}/
+      @text[regex, 1]
     end
 
     # Slices array to subarrays with identical neighbor elements
@@ -71,45 +75,19 @@ module RegexGenerator
     def options
       return @options unless @options.any?
 
-      if @options[:self_recognition].is_a? String
+      if @options[:self_recognition].kind_of? String
         @options[:self_recognition] = @options[:self_recognition].chars
       end
 
       @options
     end
 
-    def target_to_s(target)
-      return target.to_s unless target.is_a? Hash
-
-      target.each_with_object({}) do |(key, value), result|
-        result[key] = value.to_s
-      end
-    end
-
-    # Checks if target is present in the text
-    def target_present?
-      return @target.values.all? { |t| @text[t] } if @target.is_a? Hash
-
-      !@text[@target].nil?
-    end
-
-    # If keys false, method returns array with escaped values, otherwise hash
-    # with escaped values (only if target is a hash)
-    def escaped_target(keys: false)
-      return Regexp.escape @target if @target.is_a? String
-      return @target.values.map { |v| Regexp.escape v } unless keys
-
-      @target.each_with_object({}) do |(key, value), result|
-        result[key] = Regexp.escape value
-      end
-    end
-
     # Recognizes target depending on type (String or Hash)
     def target_patterns
-      return escaped_target(keys: true) if @options[:exact_target]
+      return @target.escape(keys: true) if @options[:exact_target]
 
-      if @target.is_a? Hash
-        @target.each_with_object({}) do |(key, value), patterns|
+      if @target.kind_of? Hash
+        @target_str.each_with_object({}) do |(key, value), patterns|
           slices_patterns = slice_to_identicals(recognize(value))
           patterns[key] = join_patterns(slices_patterns)
         end
@@ -121,21 +99,21 @@ module RegexGenerator
 
     # Recognizes text depending on target type
     def recognize_text(text, options = {})
-      unless @target.is_a? Hash
+      unless @target.kind_of? Hash
         return recognize(text, options) << "(#{target_patterns})"
       end
 
-      target_regex = /#{escaped_target.join('|')}/
+      target_regex = /#{@target.escape.join('|')}/
       text.split(/(#{target_regex})/).map do |str|
         next recognize(str, options) unless str[target_regex]
 
-        key = @target.key(str)
+        key = @target_str.key(str)
         "(?<#{key}>#{target_patterns[key]})"
       end.flatten
     end
 
     def recognize(text, options = {})
-      RegexGenerator::CharactersRecognizer.recognize(text, options)
+      RegexGenerator::CharactersRecognizer.recognize(text.to_s, options)
     end
   end
 end

data/lib/regex_generator/target.rb

@@ -0,0 +1,49 @@
+module RegexGenerator
+  class Target
+    # @param target [String, Integer, Float, Hash] target string or hash with
+    #   named targets
+    def initialize(target)
+      @target = target
+    end
+
+    # @param text [String] which should contains the target
+    # @return [true, false]
+    def present?(text)
+      return to_s.values.all? { |t| text[t] } if kind_of? Hash
+
+      !text[to_s].nil?
+    end
+
+    # Converts target to string (or values to strings if target is a Hash)
+    #
+    # @return [String, Hash]
+    def to_s
+      return @target.to_s unless @target.kind_of? Hash
+
+      @target.each_with_object({}) do |(key, value), result|
+        result[key] = value.to_s
+      end
+    end
+
+    # Checks type of the target's string representation
+    #
+    # @param type [Class]
+    # @return [true, false]
+    def kind_of?(type)
+      to_s.kind_of? type
+    end
+
+    # Escapes values
+    #
+    # @option keys [true, false] returns Hash with escaped values when true
+    # @return [String, Array, Hash]
+    def escape(keys: false)
+      return Regexp.escape to_s if kind_of? String
+      return to_s.values.map { |v| Regexp.escape v } unless keys
+
+      to_s.each_with_object({}) do |(key, value), result|
+        result[key] = Regexp.escape value
+      end
+    end
+  end
+end

data/lib/regex_generator/version.rb

@@ -1,3 +1,3 @@
 module RegexGenerator
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regex_generator
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - o.vykhor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-29 00:00:00.000000000 Z
+date: 2019-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,6 +72,7 @@ files:
 - lib/regex_generator/characters_recognizer.rb
 - lib/regex_generator/exceptions.rb
 - lib/regex_generator/generator.rb
+- lib/regex_generator/target.rb
 - lib/regex_generator/version.rb
 - regex_generator.gemspec
 homepage: https://github.com/oleksiivykhor/regex_generator
@@ -93,8 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Simple regex generator