ruby_list_comprehension 0.2.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da0d475e01e660a109eff36d8f0f4f8ca3e105757bf6577bfdce20c7440177b5
-  data.tar.gz: e36bcd2fa8ba9e34fce4f78efb9f4853e7fff9469573dc1da1eb3fc447e17d4b
+  metadata.gz: 95831203a1a00b6e900cb5fa9ec453fdf798ac177eeed2b7ca5fd7f5ea152afd
+  data.tar.gz: 3672b3b9fc66ee631e34f9535868093aaf2a88294edfbc0fba20249f8bd97374
 SHA512:
-  metadata.gz: 0116246f99df3cb5f403963e4743fcc34c88d9767434c9505454078b29c8a0814f84ec7ca21a22ffc309b433a4dd5f7c1944a1b695049196f09253072f379d1f
-  data.tar.gz: 905a24fdd92c58f87e4cf7e0539f0b711e7689564e825a1a84168609a1a320b9e9856ad5544fb5c2e25cbdfbfe721fb3186c34334ac031d4905c28ce20bab149
+  metadata.gz: a9becdd8385020e8cfc668c80313847e33f4440474619cf6c2abb7ac40a9f63b347213904dde0f158b8ae37d6c6c08726e2830a03624e9b8560674e8ef3bae5d
+  data.tar.gz: 9fba4623572daf749efefa775b1456918dee7afd1a6b857e5d5c6c4771550afa27571fddf6baca5510bd7769a814f495f3f89ff87532f52ac2f48dd60126afe2

data/lib/ruby_list_comprehension.rb

@@ -2,14 +2,17 @@
 require 'readline'
 require 'singleton'
 require 'set'
+
 module RubyListComprehension
   FM_REGEX = /for(?<parameter>.*)(?=in)in(?<iterable>.*)(?=do)do(?<mappable>.*)(?=if)if(?<filterable>.+)end/.freeze
   F_REGEX = /for(?<parameter>.*)(?=in)in(?<iterable>.*)(.+)do(.+)(?=if)if(?<filterable>.*)end/.freeze
   M_REGEX = /(?=for)for(?<parameter>.*)(?=in)in(?<iterable>.*)(?=do)do(?<mappable>.*)(?=end)end/.freeze
   I_REGEX = /for(?<parameter>.*)(?=in)in(?<iterable>.*)(?=do)do(?<identity>.+)(?=end)end/.freeze
 
+  private
+
   def fetch_capture(data, name)
-    data[name.to_sym] if data.names.include?(name.to_s)
+    data[name.to_sym] if data.names.include?(name.to_s) && !data.nil?
   end
 
   def op_type(str)
@@ -19,42 +22,40 @@ module RubyListComprehension
     match_identity = str.match(I_REGEX)
     parameter = fetch_capture(match_identity, :parameter)
     mappable = fetch_capture(match_map, :mappable)
-    if match_filter_map.nil? && match_filter.nil?
-      if parameter.strip == mappable.strip || /\A\s*\Z/ === mappable
-        return :identity
-      else
-        return :map
-      end
-    end
     map_condition = mappable.split('if')[0]
-    if fetch_capture(match_map, :mappable).include?('if') && !(parameter.strip == map_condition.strip || /\A\s*\Z/ === mappable)
-      return :filter_map
+
+    if match_filter_map.nil? && match_filter.nil? && (parameter.strip == mappable.strip || /\A\s*\Z/ === mappable)
+      return :identity
+    elsif match_filter_map.nil? && match_filter.nil?
+      return :map
+    end
+
+    if fetch_capture(match_map, :mappable).include?('if') &&
+      !(parameter.strip == map_condition.strip || /\A\s*\Z/ === mappable)
+      :filter_map
     else
       if match_identity[:parameter].strip == match_filter[:filterable].strip
         return :identity
       end
-      return :filter
+      :filter
     end
   end
 
   def denest_builder(nested_list)
-    nested_list
-    nested_list
-    len = 0
-    nested_list
-    fin = nested_list.split('[').delete_if{|x| x == ""}
-    fin = fin.map{|str|str[0..-1] + " end"}
-    fin = fin.join.split('],')
-    fin = fin.join.split(' end')
-    fin.map{|x|"#{x} end"}
+    nested_list.split('[')
+      .delete_if{|x| x == ""}
+      .map{|str|str[0..-1] + " end"}
+      .join.split('],')
+      .join.split(' end')
+      .map{|x|"#{x} end"}
   end
 
   def denest_flattener(nested_list)
-    nested_list
-    len = nested_list.index('for')
-    nested_list_array = nested_list.split(" end").join
-    nested_list_array.split(' end')
-    nested_list_array = nested_list_array.split('for')[1..-1].map!{|x|"for#{x} end"}
+    nested_list.split(" end")
+     .join
+     .split(' end')
+     .split('for')[1..-1]
+     .map!{|x|"for#{x} end"}
   end
 
   def create_protocol(denested_array, operator_array)
@@ -82,7 +83,6 @@ module RubyListComprehension
     i = 0
     until op_array.empty?
       current_data = match_data_array[i]
-      current_op = op_array[0]
       $iterable_string = fetch_capture(current_data, 'iterable')
       $mappable = fetch_capture(current_data, 'mappable')
       $parameter = fetch_capture(current_data, 'parameter')
@@ -97,64 +97,63 @@ module RubyListComprehension
         if !@nested
           return *$iterable
         elsif i.zero? && !@flattener
-          $process_str += "(#$iterable).map"
+          $process_str += "(#{$iterable}).map"
         elsif i.zero? && @flattener
-          $process_str += "(#$iterable).flat_map"
+          $process_str += "(#{$iterable}).flat_map"
         elsif !i.zero? && i != start_index
-          $process_str += "{(#$iterable).map"
+          $process_str += "{(#{$iterable}).map"
         elsif i == start_index
-          $process_str += "{(#$iterable_string).map(&:itself)"
+          $process_str += "{(#{$iterable_string}).map(&:itself)"
           $process_str += '}' * (start_index)
         elsif nested && i.zero? && !flatten
-          $process_str += "(#$iterable).map"
+          $process_str += "(#{$iterable}).map"
         elsif i != 0 && nested
-          $process_str += "(#$iterable_string).map"
+          $process_str += "(#{$iterable_string}).map"
         end
       when :map
         if i == 0
           $mappable = $parameter if /\A\s*\Z/ === $mappable
-          $process_str += "(#$iterable).map{|(#$parameter)|(#$mappable)}"
+          $process_str += "(#{$iterable}).map{|#{$parameter}|(#{$mappable})}"
         elsif i == 0 && flatten
           $mappable = $parameter if /\A\s*\Z/ === $mappable
-          $process_str += "(#$iterable).flat_map{|(#$parameter)|(#$mappable)"
+          $process_str += "(#{$iterable}).flat_map{|#{$parameter}|(#{$mappable})"
         elsif i == 0 && !flatten
           $mappable = $parameter if /\A\s*\Z/ === $mappable
-          $process_str += "(#$iterable).map{|(#$parameter)|(#$mappable)"
+          $process_str += "(#{$iterable}).map{|#{$parameter}|(#{$mappable})"
         elsif i == start_index
           $mappable = $parameter if /\A\s*\Z/ === $mappable
-          $process_str += "{(#$iterable).map{|(#$parameter)|(#$mappable)"
+          $process_str += "{(#{$iterable}).map{|#{$parameter}|(#{$mappable})"
           $process_str += '}' * (start_index+1)
         elsif i != start_index
-          $process_str += "{(#$iterable_string).map{|(#$parameter)|(#$mappable)"
+          $process_str += "{(#{$iterable_string}).map{|#{$parameter}|(#{$mappable})"
         end
       when :filter
         if op_array.empty?
-          $process_str += "(#$iterable).filter{|(#$parameter)|(#$filterable)}"
+          $process_str += "(#{$iterable}).filter{|#{$parameter}|(#{$filterable})}"
         end
       when :filter_map
         if op_array.empty? && RUBY_VERSION >= '2.7.0'
-          $process_str += "(#$iterable).filter_map{|(#$parameter)|(#$mappable)  if  (#$filterable)}"
+          $process_str += "(#{$iterable}).filter_map{|#{$parameter}|(#{$mappable})  if  (#{$filterable})}"
         else
-          $process_str += "(#$iterable).map{|(#$parameter)|(#$mappable)  if  (#$filterable)}.compact"
+          $process_str += "(#{$iterable}).map{|#{$parameter}|(#{$mappable})  if  (#{$filterable})}.compact"
         end
       end
       i += 1
-      # p $process_str
     end
     begin
-      current_op
       instance_eval($process_str)
     rescue SyntaxError => e
-      'List imcomprehensible :' + e.backtrace_locations.to_s
+      "List incomprehensible: #{e.backtrace_locations.to_s}"
+    rescue Error => e
+      "Check your assumptions, something is amiss: #{e.backtrace_locations.to_s}"
     end
   end
 
   def one_shot(str)
     len = str.scan('for ').length
-    @nested = (len > 1)
-    nested = @nested
-    if nested
-      nest_mode = str.include?('end end') && !nested ? :flatten : :matrix
+    @nested = len > 1
+    if @nested
+      nest_mode = str.include?('end end') && !@nested ? :flatten : :matrix
       nest_array = @flattener ? denest_flattener(str) : denest_builder(str)
     else
       nest_array = [str]
@@ -162,46 +161,43 @@ module RubyListComprehension
     op_array = nest_array.map(&method(:op_type))
     hash = create_protocol(nest_array, op_array)
     begin
-      execute_comprehension(hash, nest_mode==nested)
+      execute_comprehension(hash, nest_mode==@nested)
     rescue SyntaxError => se
       puts 'RESCUED!' + se.backtrace_locations.to_s
     end
   end
 
   class ListComprehension
-    # include Singleton
+    include Singleton
     include RubyListComprehension
-    attr_accessor :cache, :caching, :mappable, :filterable, :iterable, :var, :list, :location, :line, :count
-    attr_accessor :flattener, :len, :nested, :nested_var, :file, :list_comp, :final_iterable_value
-    attr_accessor :count
-    REPL_LIST = %w[:irb :pry].freeze
+    attr_accessor :cache, :mappable, :filterable, :line, :flattener
 
-    def initialize
-      @cache = {}
-      @caching = true
-      @version = RUBY_VERSION
-    end
+    :TOO_MANY_COMPS_ON_ONE_LINE
 
     def [](*iterable)
       return [] if iterable.empty? || iterable.nil?
 
-
       @flattener = iterable.length == 1
-      iterable = iterable[0] if iterable.length == 1
-      @final_iterable_value = iterable
-      @list_comp = iterable
-      $iterable = iterable
+      $iterable = iterable[0] if iterable.length == 1
+
       @filename = $PROGRAM_NAME
       if @filename == "pry" || @filename == "irb"
         @line = locate_list_repl
       else
         @line = locate_list_file
       end
+      return @line if @line == :TOO_MANY_COMPS_ON_ONE_LINE
       return @cache[@line] if @cache.has_key?(@line)
 
       @cache[@line] = one_shot(@line)
     end
 
+    private
+
+    def initialize
+      @cache = {}
+    end
+
     def locate_list_repl
       @line = Readline::HISTORY.to_a.reverse.uniq.reverse[-1]
       start = @line.index('l[') + 2
@@ -217,16 +213,12 @@ module RubyListComprehension
     end
 
     def locate_list_file
-      @location = caller_locations.last.to_s.scan(/\d+/).last.to_i
-      @line = retrieve_file_data[@location - 1].strip.match(/\$l(?<line>.+)/)[:line][0...-1]
-      # if @line.is_a? Array
-      #   @line.each_with_index do |list, idx|
-      #   list.split[3] == iterable.to_s
-      #   @line = list[0..list.index('end]') + 2] if list.split[3] == iterable.to_s
-      #   end
-      # end
+      @line = retrieve_file_data[caller_locations.last.to_s.scan(/\d+/).last.to_i - 1]
+                .strip.match(/\$l(?<line>.+)/)[:line][0...-1]
+                .sub(";", " do ")
+      @line = :TOO_MANY_COMPS_ON_ONE_LINE if @line.include?("$l")
       @line
     end
   end
-  $l = ListComprehension.new
+  $l = ListComprehension.instance
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: ruby_list_comprehension
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Samuel Michael
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-02 00:00:00.000000000 Z
+date: 2020-12-04 00:00:00.000000000 Z
 dependencies: []
 description: List Comprehensions for Ruby
-email: smichael@appacademy.io
+email: sammomichael@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -28,7 +28,7 @@ metadata:
   mailing_list_uri: https://groups.example.com/bestgemever
   source_code_uri: https://github.com/SammoMichael/Ruby_List_Comprehension/blob/master/lib/ruby_list_comprehension.rb
   wiki_uri: https://github.com/SammoMichael/Ruby_List_Comprehension/wiki
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -43,8 +43,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Ruby List Comprehension
 test_files: []