ruby_list_comprehension 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25d56bf9d1cd2645750c99f4f46678893ba00e6d4075712a5ac7b845aa479412
-  data.tar.gz: f30a9fbd24e4595c1bde00bb344d9482f499e8ae87cb6e04035ef5123c94b8aa
+  metadata.gz: fa7eade3470c5cf0a30200ae86f39f05383804d6ddc0e35faa3fb18d01da7dcc
+  data.tar.gz: 1ce2185e0da4ee30e402ee844bd1a87d5beacb2faf263fdd13618ae6e7eba1d7
 SHA512:
-  metadata.gz: 90526fa524e2b0377da07dd436f6011fa2d38e1363639caf19d58ed8afb36c04501708058d3ab6feb86f4c8452af9d281d07a3cbd122eba6c51855e6e2c22461
-  data.tar.gz: 210c7af5d5a6355c7a38a9276e802c689561f299fed9ed23c24bbfe37c6b5c5b35bd27f9e4c7afc3f575cd0473d9f3b4e03ed444cad09ed0cd52a37b68b27ee2
+  metadata.gz: a122824fd982fdfecf007a83860b8006a4cefbeed77013be38b10284d3b6c1e3e525d45c131cce0d6dc405af581a417639ee65141bbb85cf07d053c6a23520d5
+  data.tar.gz: e9b2476e5f6ac2cf86910218642a21c4c2c7cbd679d70654c4b0ad5f403cac0563b81df25704f8c6392db44e57e4a2d8f56207b62b3b4542ddb762db63201cc8

data/lib/ruby_list_comprehension.rb

@@ -1,130 +1,230 @@
 # frozen_string_literal: true
-
 require 'readline'
+require 'singleton'
+require 'set'
+module RubyList
+  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
 
-class ListComprehension
-  attr_accessor :cache, :caching, :mappable, :filterable, :iterable, :var, :list, :location, :line
-  attr_reader :c, :version, :op, :cache_count, :filename
+  def fetch_capture(data, name)
+    data[name.to_sym] if data.names.include?(name.to_s)
+  end
 
-  def [](list_comp)
-    if @filename == 'pry' || @filename == 'irb'
-      @line = Readline::HISTORY.to_a.uniq[-1].strip
-      start = @line.index('l[') + 2
-      ending = @line[start..-1].index('end') + 5
-      @line = @line[start...ending]
+  def op_type(str)
+    match_map = str.match(M_REGEX)
+    match_filter_map = str.match(FM_REGEX)
+    match_filter = str.match(F_REGEX)
+    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
     else
-      @location = caller_locations.last.to_s.scan(/\d+/).last.to_i
-      file = File.open($PROGRAM_NAME)
-      file_data = file.readlines.map(&:chomp)
-      file.close
-      @line = file_data[@location - 1].strip
-      start = @line.index('l[')
-      ending = @line[start..-1].index('end')
-      @line = @line[start+2...ending + 6].chop
+      if match_identity[:parameter].strip == match_filter[:filterable].strip
+        return :identity
+      end
+      return :filter
     end
-    # p @line
-    c[@line]
   end
 
-  def initialize
-    @filename = $PROGRAM_NAME
-    @cache = {}
-    @count = 0
-    @op = {}
-    @cache_count = 0
-    @caching = true
-    @version = RUBY_VERSION
-    @c = lambda { |list| # check for cached results
-      return [] unless list.is_a? String
-
-      @list = list.strip
-      case list
-      when '{}' then return [{}]
-      when '[]' then return [[]]
-      when '' then return []
-      else list += ' end' unless list.include?('end')
-      end
-      raise 'syntax error in list comprehension' if list.length < 10
-
-      if @caching && @cache[list]
-        @cache_count += 1
-        return @cache[list]
-      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"}
+  end
 
-      copy1 = list[0..-1]
-      arr = list.split
-      @var = arr[1]
+  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"}
+  end
 
-      # replace initial semicolon with do if needed for parser
-      if arr[3..-1].any? { |x| x.include?(';') } && !arr.include?('do')
-        arr = list.to_s.sub(';', ' do ').split
-      end
-      arr.insert(-2, 'do') if arr.none? { |x| x.include?('do') } && arr.none? { |x| x.include?('do') }
-
-      # pre-eval to check for invalid syntax
-      begin
-        res = instance_eval(arr.join(' '))
-        return [] if res.nil?
-      rescue SyntaxError => se
-        raise 'incorrect syntax for list comprehension' + "\n" + se.to_s
+  def create_protocol(denested_array, operator_array)
+    operator_array.each_with_object({}).with_index do |(e, o), i|
+      case e
+      when :filter
+        o[i] = [e, denested_array[i].match(F_REGEX)]
+      when :filter_map
+        o[i] = [e, denested_array[i].match(FM_REGEX)]
+      when :map
+        o[i] = [e, denested_array[i].match(M_REGEX)]
+      when :identity
+        o[i] = [e, denested_array[i].match(I_REGEX)]
       end
+    end
+  end
+
+  def execute_comprehension(hash, flatten = true)
+    $process_str = ''
+    op_array = hash.values.map{|x,|x}
+    start_index = op_array.length - 1
+    nested = op_array.length > 1
+    match_data_array = hash.values.map{|_,x|x}
 
-      # check for hash to parse csv's
-      iterable = arr[3]
-      return [{}] if iterable == '{}'
-      
-      m_data = copy1[3...copy1.rindex('do')].match(/({.+[=>:].+})/)
-      if m_data
-        first_hash = m_data[0].split(';')[0]
-        if @list.index(first_hash) == 9
-          iterable = first_hash if instance_eval(first_hash).is_a? Hash
+    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')
+      $filterable = fetch_capture(current_data, 'filterable')
+      $identity = fetch_capture(current_data, 'identity')
+      $iterable = Array($iterable) if $iterable.class == Set
+      $iterable = fetch_capture(current_data, 'iterable') if i != 0
+      $iterable = $iterable_string if !flatten && @nested
+      case op_array.shift
+      when :identity
+        flatten = @flattener
+        if !@nested
+          return *$iterable
+        elsif i.zero? && !@flattener
+          $process_str += "(#$iterable).map"
+        elsif i.zero? && @flattener
+          $process_str += "(#$iterable).flat_map"
+        elsif !i.zero? && i != start_index
+          $process_str += "{(#$iterable).map"
+        elsif i == start_index
+          $process_str += "{(#$iterable_string).map(&:itself)"
+          $process_str += '}' * (start_index)
+        elsif nested && i.zero? && !flatten
+          $process_str += "(#$iterable).map"
+        elsif i != 0 && nested
+          $process_str += "(#$iterable_string).map"
         end
-      end
-      @iterable = instance_eval(iterable)
-      # p @iterable
-      if_condition = arr.include?('if') ? arr[arr.index('if') + 1...-1] : ['true']
-      map_condition = arr[arr.index('do') + 1...(arr.index('if') || arr.index('end'))]
-      @filterable = if_condition.join(' ')
-      @mappable = map_condition.join(' ')
-      ### list_comprehension identity currently uses for(each) as if normal ruby
-      # p @filterable
-      # p @mappable
-      return *@iterable if (@mappable == @var || @mappable == '') && (@filterable == 'true' || @filterable == @var)
-
-      # define a method to handle the transformation to list_comp
-      self.class.send(:define_method, 'lc') do |arr|
-
-        if @mappable == @var
-          @op[@count] = 'filter'
-          @count += 1
-          return @iterable.filter { |x| instance_eval(@filterable.gsub(@var, x.to_s)) }
+      when :map
+        if i == 0
+          $mappable = $parameter if /\A\s*\Z/ === $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)"
+        elsif i == 0 && !flatten
+          $mappable = $parameter if /\A\s*\Z/ === $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 += '}' * (start_index+1)
+        elsif i != start_index
+          $process_str += "{(#$iterable_string).map{|(#$parameter)|(#$mappable)"
         end
-
-        if @filterable == 'true' || @filterable == @var
-          @op[@count] = 'map'
-          @count += 1
-          return @iterable.map { |x| instance_eval(@mappable.gsub(@var, x.to_s)) }
+      when :filter
+        if op_array.empty?
+          $process_str += "(#$iterable).filter{|(#$parameter)|(#$filterable)}"
         end
-
-        filter_map_condition_args = "#@mappable if #@filterable"
-        # check Ruby Version stored in @version
-        if @version >= '2.7.0'
-          @op[@count] = 'filter_map'
-          @count += 1
-          return @iterable.filter_map { |x| instance_eval(filter_map_condition_args.gsub(@var, x.to_s)) }
+      when :filter_map
+        if op_array.empty? && RUBY_VERSION >= '2.7.0'
+          $process_str += "(#$iterable).filter_map{|(#$parameter)|(#$mappable)  if  (#$filterable)}"
         else
-          @op[@count] ="map&compact"
-          @count += 1
-          @iterable.map { |x| instance_eval(filter_map_condition_args.gsub!(@var, x.to_s)) }.compact!
+          $process_str += "(#$iterable).map{|(#$parameter)|(#$mappable)  if  (#$filterable)}.compact"
         end
       end
-      list_comp = lc(arr)
-      unless list_comp.is_a?(Array) || list_comp.is_a?(Hash)
-        list_comp = [list_comp]
-      end
-      list_comp = list_comp == [nil] ? [] : list_comp
-      # p @op
-      @cache[list] = list_comp if @caching
-    }
+      i += 1
+      # p $process_str
+    end
+    begin
+      current_op
+      instance_eval($process_str)
+    rescue SyntaxError => e
+      'List imcomprehensible :' + 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
+      nest_array = @flattener ? denest_flattener(str) : denest_builder(str)
+    else
+      nest_array = [str]
+    end
+    op_array = nest_array.map(&method(:op_type))
+    hash = create_protocol(nest_array, op_array)
+    begin
+      execute_comprehension(hash, nest_mode==nested)
+    rescue SyntaxError => se
+      puts 'RESCUED!' + se.backtrace_locations.to_s
+    end
+  end
+
+  class ListComprehension
+    include Singleton
+    include RubyList
+    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
+
+    def initialize
+      @cache = {}
+      @caching = true
+      @version = RUBY_VERSION
+    end
+
+    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
+      @filename = $PROGRAM_NAME
+      @line = REPL_LIST.include?(@filename.to_sym) ? locate_list_repl : locate_list_file
+      return @cache[@line] if @cache.has_key?(@line)
+
+      @cache[@line] = one_shot(@line)
+    end
+
+    def locate_list_repl
+      @line = Readline::HISTORY.to_a.reverse.uniq.reverse[-1]
+      start = @line.index('l[') + 2
+      ending = @line[start..-1].index('end') + 5
+      @line = @line[start...ending]
+    end
+
+    def retrieve_file_data
+      @file = File.open($PROGRAM_NAME)
+      file_data = @file.readlines.map(&:chomp)
+      @file.close
+      file_data
+    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
+
+    end
   end
+  $l = ListComprehension.instance
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_list_comprehension
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Samuel Michael
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2010-04-28 00:00:00.000000000 Z
+date: 2019-10-02 00:00:00.000000000 Z
 dependencies: []
 description: List Comprehensions for Ruby
 email: smichael@appacademy.io