ruby_list_comprehension 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2d35273a3ae0a52a219848adb715d96ca5f13dbd0eb500c4ae80ea2cc151977
-  data.tar.gz: b5ddeb3771d13d9c314f0bc7588db1d918b79396fe32e4b27b87fa86812d8a53
+  metadata.gz: c98ac6df6bb53e83ad1eafbb630dae2bdfd4f751ae3980d8cd3dfeabe0f38cbe
+  data.tar.gz: 0c3bf63664daf1987027bcb719b5e9fe3cbf1fa816d151f9a0881ec803710acc
 SHA512:
-  metadata.gz: 302c90d601a6affe56d8a06567ec6ea3071f216e274131f7184185a082e77ebd7b6a23752feb6222a602fbb84828ed6fcbc1511c381728ddf86af26d0c4d4156
-  data.tar.gz: 8a60c0e66d4e6defc8a3b728cc2b4a656ac8c12237a14a96d51447b440049bd0234c4b07fcd29b68fc0cfb5ae8519a9f301d69ef95202a1bde00b73b4c883d8a
+  metadata.gz: 2622a26bde77b8f3ee314a52db76e2650d0020a9c18ca4a38c147a98a7aeb4762af5a52e8878baa33a1677764525a62dbb321a6de080b8133029dd901f9e4335
+  data.tar.gz: 300dd50e3138851e1ad102dd1551fb37cc7604f970f1162c4de0f36d4146c66be18a397b443463cc7e4a9963d1fa6796736c7a9d6953888d9d9c930ecaf754d7

data/lib/ruby_list_comprehension.rb

@@ -1,44 +1,52 @@
 # frozen_string_literal: true
 
 class ListComprehension
-  attr_accessor :cache, :caching
-  attr_reader :c, :version, :op
+  attr_accessor :cache, :caching, :mappable, :filterable, :iterable, :var, :list
+  attr_reader :c, :version, :op, :cache_count
 
-  def [](*args)
-    c[*args]
+  def [](list_comp)
+    c[list_comp]
   end
 
   def initialize
     @cache = {}
-    @op = nil
+    @count = 0
+    @op = {}
+    @cache_count = 0
     @caching = true
     @version = RUBY_VERSION
-    @c = lambda { |x| # check for cached results
-      return [] if x == ''
-      x.concat(' end')if x[-3..-1] != 'end'
-      return @cache[x] if @caching && @cache[x]
-
-      # p "cached: #{@cache[arr].to_s}" if @cache[arr]
+    @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
 
-      y = x[0..-1] # copy of original call
-      z = y[0..-1] # copy of original call
-      return [] if x.empty? || x == '' || x.nil? || eval(z[3]) == '[]'
-      raise 'syntax error in list comprehension' if x.length < 10
+      if @caching && @cache[list]
+        @cache_count += 1
+        return @cache[list]
+      end
 
-      raise 'please use "x" as block parameter name for now' if x[3..5] != ' x '
+      copy1 = list[0..-1]
+      arr = list.split
+      @var = arr[1]
 
-      arr = x.split
-      if !arr.include?('do')
-        arr.insert(5, 'do')
-      end
       # replace initial semicolon with do if needed for parser
-      if arr[3][-1] == ';' || arr[4][0] == ';' || arr[5][0] == ';' && !arr.include?('do')
-        arr = x.to_s.sub(';', ' do ').split
+      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')}
+      # p arr
 
       # pre-eval to check for invalid syntax
       begin
-        res = instance_eval(x)
+        # p arr.join(' ')
+        res = instance_eval(arr.join(' '))
         return [] if res.nil?
       rescue SyntaxError => se
         raise 'incorrect syntax for list comprehension' + "\n" + se.to_s
@@ -46,73 +54,61 @@ class ListComprehension
 
       # check for hash to parse csv's
       iterable = arr[3]
-      return [{}] if iterable == "{}"
-
-      mdata = y[3...y.rindex('do')].match(/{.+[=>:].+}/)
-      if mdata && mdata[0].include?(';')
-        # p 'hi'
-        iterable = mdata[0].split(';')[0]
-        # p iterable
-        # p arr.insert(5, "do")
-      end
-      if mdata
-        if instance_eval(mdata[0]).is_a? Hash
-          iterable = mdata[0]
-          p mdata[0]
-          p iterable
-          p arr
-
-          if iterable[-1] == ';'
-            iterable = iterable[0..-1]
+      return [{}] if iterable == '{}'
+      m_data = copy1[3...copy1.rindex('do')].match(/({.+[=>:].+})/)
+      if m_data
+        first_hash = m_data[0].split(';')[0]
+        if arr.index(first_hash) == 3
+          if instance_eval(m_data[0].split(';')[0]).is_a? Hash
+            iterable = m_data[0].split(';')[0]
           end
         end
       end
-
+      @iterable = instance_eval(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'))]
-
-      if (map_condition == [arr[1]]) && (if_condition == ['true'])
-        @op = "each"
-        res = instance_eval(iterable)
-        return res.is_a?(Array) ? res : [res]
-      end
+      @filterable = if_condition.join(' ')
+      @mappable = map_condition.join(' ')
+      # p @mappable
+      ### 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 map_condition.include?(arr[1])
-          @op = 'filter'
-          return instance_eval(iterable).filter do |x|
-            instance_eval(if_condition.join(' '))
-          end
+
+        if @mappable == @var
+          @op[@count] = 'filter'
+          @count += 1
+          return @iterable.filter { |x| instance_eval(@filterable.gsub(@var, x.to_s))}
         end
 
-        if if_condition.include?('true' || 'x') || if_condition
-          @op = 'map'
-          return instance_eval(iterable).map do |x|
-            instance_eval(map_condition.join(' '))
-          end
+        if @filterable == 'true' || @filterable == @var
+          @op[@count] = 'map'
+          @count += 1
+          return @iterable.map { |x| instance_eval(@mappable.gsub(@var, x.to_s))}
         end
 
+        filter_map_condition_args = "#@mappable if #@filterable"
         # check Ruby Version stored in @version
         if @version >= '2.7.0'
-          @op = 'filter_map'
-          return instance_eval(iterable).filter_map do |x|
-            instance_eval(map_condition.join(' ')) if instance_eval(if_condition.join(' '))
-          end
+          @op[@count] = 'filter_map'
+          @count += 1
+          return @iterable.filter_map { |x| instance_eval(filter_map_condition_args.gsub(@var, x.to_s)) }
         else
-          @op = 'map&compact'
-          return instance_eval(iterable).map do |x|
-            instance_eval(map_condition.join(' ')) if instance_eval(if_condition.join(' '))
-          end.compact!
+          @op[@count] = 'map&compact'
+          @count += 1
+          @iterable.map { |x| instance_eval(filter_map_condition_args.gsub!(@var, x.to_s)) }.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
-      @cache[arr] = list_comp if @caching
+      # p @op
+      @cache[list] = list_comp if @caching
     }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_list_comprehension
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Samuel Michael
@@ -43,7 +43,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Ruby List Comprehension