eco-helpers 0.6.0

data/lib/eco/language/models.rb

@@ -0,0 +1,11 @@
+module Eco
+  module Language
+    module Models
+    end
+  end
+end
+
+require_relative 'models/modifier'
+require_relative 'models/collection'
+require_relative 'models/attribute_parser'
+require_relative 'models/wrap'

data/lib/eco/language/models/attribute_parser.rb

@@ -0,0 +1,38 @@
+module Eco
+  module Language
+    module Models
+
+      class AttributeParser
+
+        attr_reader :attr
+
+        def initialize(attr, dependencies: {})
+          @attr = attr
+          @dependencies = dependencies
+        end
+
+        def def_parser(&block)
+          @parser = block
+          self
+        end
+
+        def def_serializer(&block)
+          @serializer = block
+          self
+        end
+
+        def parse(source, dependencies: {})
+          raise "There is no parser for this attribue '#{attr}'" if !@parser
+          @parser.call(source, @dependencies.merge(dependencies), attr)
+        end
+
+        def serialize(object, dependencies: {})
+          raise "There is no serializer for this attribue '#{attr}'" if !@serializer
+          @serializer.call(object, @dependencies.merge(dependencies), attr)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/eco/language/models/collection.rb

@@ -0,0 +1,181 @@
+module Eco
+  module Language
+    module Models
+      class Collection < Array
+
+        ATTR_PRESENCE_METHODS = ["present", "empty", "present_all?", "present_some?"]
+        ATTR_COLLECTION_METHODS = ["exclude", "remove", "attr", "attr?", "attrs", "unique_attrs", "contains"] + ATTR_PRESENCE_METHODS
+
+        #attr_reader :kclass
+
+        def initialize(data = [], klass:, factory: nil, handy: Eco::Common::Language.new)
+          raise "Raise klass required, given: #{klass}" if !klass
+          @klass   = klass
+          @factory = factory
+          @handy   = handy
+          super(to_klass(data))
+        end
+
+        def newFrom(data)
+          self.class.new(data, klass: @klass, factory: @factory)
+        end
+
+        def to_c
+          Collection.new(self, klass: @klass, factory: @factory)
+        end
+
+        def new
+          self.class.new(self.to_a, klass: @klass, factory: @factory)
+        end
+
+        def <(value)
+          self.clear << value
+          on_change
+          self
+        end
+
+        def <<(value)
+          self.concat(into_a(value))
+          on_change
+          self
+        end
+
+        def update(&block)
+          newFrom self.map(&block)
+        end
+
+        def delete(value)
+          self < self - value
+          on_change
+          self
+        end
+
+        # attr dependant methods
+        def exclude(attr, value, modifier = Language::MatchModifier.new)
+          newFrom self - self.attr(attr, value, modifier)
+        end
+
+        def remove(attr, value, modifier = Language::MatchModifier.new)
+          self < self.exclude(attr, value, modifier)
+          on_change
+          self
+        end
+
+        def attr(attr, value = true, modifier = Language::MatchModifier.new)
+          if !!value == value # boolean?
+            self.present(attr, value)
+          else
+            return newFrom self.select { |object|
+              attr_val = fetch_attr(object, attr)
+              match?(attr_val, value, modifier)
+            }
+          end
+        end
+
+        def attr?(attr, value = true, modifier = Language::MatchModifier.new)
+          modifier = modifier.new.reverse
+          if !!value == value # boolean?
+            self.present(attr, value).length == self.length
+          else
+            obj_vals = self.attrs(attr)
+            return match?(obj_vals, value, modifier)
+          end
+        end
+
+        def attrs(attr)
+          self.map { |object| fetch_attr(object, attr) }
+        end
+
+        def unique_attrs(attr)
+          self.to_h(attr).keys
+        end
+
+        def present(attr, flag = true)
+          block = ->(o) { !!fetch_attr(o, attr) == !!flag }
+          newFrom self.select(&block)
+        end
+
+        def empty(attr, flag = true)
+          self.present(attr, !flag)
+        end
+
+        def present_all?(attr, flag = true)
+          self.present(attr, flag).length == self.length
+        end
+
+        def present_some?(attr, flag = true)
+          self.present(attr, flag).length > 0
+        end
+
+        def contains(attr, value, modifier = Language::MatchModifier.new)
+          modifier = modifier.new.pattern
+          self.attr(attr, value, modifier)
+        end
+
+        def group_by(attr)
+          #self.to_h(attr)
+          return {} if !attr
+          self.to_a.group_by { |object| object.method(attr).call }
+        end
+
+        def to_h(attr)
+          return {} if !attr
+          self.to_a.group_by { |object| object.method(attr).call }
+        end
+
+        # class level methods
+        def self.attr_collection (*attrs)
+          block = ->(method) { attrs_create_method(attrs, method) }
+          ATTR_COLLECTION_METHODS.each(&block)
+        end
+
+        def self.attr_presence (*attrs)
+          block = ->(method) { attrs_create_method(attrs, method) }
+          ATTR_PRESENCE_METHODS.each(&block)
+        end
+
+        def self.attrs_create_method(attrs, method)
+          attrs.each do |attr|
+            attr = attr.to_s
+            if method.include?("attr")
+              attr_method = method.sub("attr", attr)
+            else
+              attr_method = "#{attr}_#{method}"
+            end
+            define_method attr_method do  |*args|
+              send(method, attr, *args)
+            end
+          end
+        end
+
+        protected
+
+        def on_change
+          # function to be overriden by children classes
+        end
+
+        def into_a(value)
+          value = [].push(value) unless value.is_a?(Array)
+          value
+        end
+
+        private
+
+        def match?(*args)
+          @handy.match?(*args)
+        end
+
+        def to_klass(list)
+          into_a(list).map do |v|
+            v.is_a?(@klass) ? v : @factory&.new(v) || @klass.new(v)
+          end
+        end
+
+        def fetch_attr(object,attr)
+          object.method(attr).call
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/language/models/modifier.rb

@@ -0,0 +1,68 @@
+module Eco
+  module Language
+    module Models
+      class Modifier < Array
+
+        DEFAULT_MODE      = [:default, :none]
+
+        def initialize(value = [])
+          super(into_a(value))
+        end
+
+        def new
+          self.class.new(self.resolve_mode.to_a)
+        end
+
+        # MODE MODIFIERS
+        # resolve mode
+        def mode
+          resolve_mode
+        end
+
+        def <(value)
+          self.clear << value
+        end
+
+        def <<(value)
+          self.concat(into_a(value))
+        end
+
+        def flush_mode
+          self < self.mode
+        end
+
+        def default(value)
+          #self.unshift(value)
+          reset
+        end
+
+        def reset
+          self < DEFAULT_MODE.first
+        end
+
+        def default?
+          (mode - DEFAULT_MODE).length == 0
+        end
+
+        protected
+
+        def resolve_mode
+          self.to_a
+        end
+
+        def resolve (ms, flags)
+          # later modifiers have precedence
+          flag = (ms & flags).last
+          ms = (ms - flags).push(flag) unless !flag
+          return ms
+        end
+
+        def into_a(value)
+          value = [].push(value) unless value.is_a?(Array)
+          value
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/language/models/wrap.rb

@@ -0,0 +1,114 @@
+module Eco
+  module Language
+    module Models
+      class Wrap
+
+        attr_reader :setters, :getters
+        attr_reader :object
+
+        def initialize(object = nil, setters: [], getters: [])
+          @object = object
+          self.setters = setters
+          self.getters = getters
+        end
+
+        def getters=(value)
+          @getters = into_a(value)
+          @wgetters = wrap_object(@object, @getters)
+        end
+
+        def setters=(value)
+          @setters = into_a(value)
+          @wsetters = wrap_object(@object, @setters)
+        end
+
+        def object=(value)
+          @object = value
+          @wgetters = wrap_object(@object, @getters)
+          @wsetters = wrap_object(@object, @setters)
+        end
+
+        def <<(value = [])
+          value = into_a(value)
+          @wsetters.each_with_index.map do |set, i|
+            args = into_a(value[i])
+            set.call(*args)
+          end
+        end
+
+        def row(value = (miss = true; []))
+          value = into_a(value)
+          @wgetters.each_with_index.map do |get, i|
+            args = into_a(value[i])
+            get.call(*args) unless miss
+            get.call
+          end
+        end
+
+        def wrap_object(object = nil, ops = [])
+          object = object || @object
+          return [] unless !!object
+          into_a(ops).map do |op|
+            cop = required_parameters?(op) ? curry(op) : op
+            ->(*args) {
+              args.unshift(object);
+              #puts "calling wop: #{cop}, with args: #{args}, object: #{object}"
+              cop[*args] #rescue nil
+            }
+          end
+        end
+
+        module Test
+          class A
+            attr_accessor :a, :e
+            def initialize(val)
+              self.a = val
+              @e = 2
+            end
+            def exp
+              @a**@e
+            end
+          end
+        end
+
+        def self.test()
+          # setters
+          soa = ->(o,v) { o.a = v }
+          soe = ->(o,v) { o.e = v }
+          # getters
+          goa  = ->(o) { o.a }
+          goe  = ->(o) { o.e }
+          goex = ->(o) { o.exp }
+
+          # arrays
+          setters = [soa, soe ]
+          getters = [goa, goe, goex]
+
+          a = Test::A.new(3)
+          b = Test::A.new(5)
+          w = self.new(a, setters: setters, getters: getters)
+
+          puts "before check  -> a: #{a.a}; e: #{a.e}; exp: #{a.exp}"
+          # launch setters
+          w << [4, 2]
+          puts "after setters -> a: #{a.a}; e: #{a.e}; exp: #{a.exp}"
+          # launch getters
+          a, e, exp = w.row
+          puts "from getters(a) -> a: #{a}; e: #{e}; exp: #{exp}"
+          # switch object
+          w.object = b
+          # launch getters
+          a, e, exp = w.row
+          puts "from getters(b) -> a: #{a}; e: #{e}; exp: #{exp}"
+        end
+
+        private
+
+        def into_a(value)
+          value = [].push(value) unless value.is_a?(Array)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/eco/language/values_at.rb

@@ -0,0 +1,159 @@
+module Eco
+  module Language
+
+    def to_key(pr)
+      pr.is_a?(Hash) ? pr.keys.first : pr
+    end
+
+    def to_value(pr)
+      pr.is_a?(Hash) ? pr.values.first : pr
+    end
+
+    def values_at(object, *attrs, **kattrs)
+      all_params = attrs + kattrs.map {|k,v| {k => v} }
+      return object.values_at(*all_params) if object.is_a?(Hash)
+      all_keys     = all_params.map        { |pr|   to_key(pr)  }
+      arguments    = all_params.each_with_index.map { |pr, i| pr.values[0] if pr.is_a?(Hash)}
+      #puts "all_keys: #{all_keys}; arguments: #{arguments}"
+      values = all_keys.each_with_index.map do |k, i|
+        a = k; v = []
+        v = arguments[i] if all_params[i].is_a?(Hash) # with params
+        attr_method = get_accessor(object, a)[object, a] rescue nil
+        #puts "attr: #{a} - method: #{attr_method}"
+        next if !attr_method
+        args = v.is_a?(Array) ? v : [].push(v)
+        attr_method = curry(attr_method) if required_parameters?(attr_method)
+        # final call to the method
+        #puts "args: #{args}"
+        value = attr_method[*args] # rescue nil
+        value = nil if value.is_a?(Proc)
+        value
+      end
+    end
+
+    # adapted from: https://stackoverflow.com/a/16908153/4352306
+    def get_accessor(object, attr, accessors: [])
+      accessors.push( ->(obj, att) { object.method(att) } )
+      #accessors.push( ->(obj, att) { object[att] } )
+      accessors.reduce(nil) { |chosen, acc| chosen ? chosen :
+          (acc[object, attr] && acc rescue nil) || chosen }
+      #accessors.reduce(nil) { |chosen, acc|
+      #    puts "attr: #{attr} => current: #{acc}"
+      #    chosen ? chosen : (acc[object, attr] && acc rescue nil) || chosen
+      #    puts "attr: #{attr} => after check - chosen: #{chosen}"
+      #    chosen
+      #  }
+    end
+
+      # enables dot notation to do object nesting access
+    def values_at_dot (object, *attrs, curry: false, debug: false, **kattrs)
+      all_params = attrs + kattrs.map {|k,v| {k => v} }
+      return object.values_at(*all_params) if object.is_a?(Hash)
+
+      to_s    = ->(k)  { ((k.to_s   rescue k) || key)        }
+      to_sym  = ->(k)  { ((k.to_sym rescue k) || key)        }
+      dotted  = ->(k)  { to_s[k].include?('.')               }
+      pdotted = ->(pr) { dotted[to_key(pr)]                  }
+      haccess = ->(dp) { # prepare call
+        k       = dp
+        k, v    = [dp.keys.first, dp.values.first] if (hash = dp.is_a?(Hash))
+        kf, kr  = [ (ss = to_s[k].split('.')).first , ss.slice(1)]
+        nxt_cll = hash ? {kr => v} : kr
+        {k => {'a' => kf, 'v' => nxt_cll }}
+      }
+      all_keys     = all_params.map        { |pr|   to_key(pr)           }
+      hash_params  = all_params.reduce({}) { |h,pr| h.merge!(pr) if pr.is_a?(Hash); h }
+      dot_params   = all_params.select     { |pr|   pdotted[pr]          }
+      dot_keys     = dot_params.map        { |dp|   to_key(dp)           }
+      dot_wrappers = dot_params.reduce({}) { |h,dp| h.merge(haccess[dp]) }
+
+      if debug
+        pp "object     : #{object}"
+        pp "all_params: #{all_params}"
+        pp "dot_keys   : #{dot_keys}"
+      end
+
+      values = all_keys.map do |k|
+        a = k; v = []
+        puts "key: #{k}" if debug
+        case true
+        when dot_keys.include?(k) # dotted (recursive)
+          dot = dot_wrappers[k]
+          a, v = dot.values_at('a', 'v')
+        when hash_params.key?(k) # no dotted, with params
+          v = hash_params[k]
+        end
+
+        attr_method = get_accessor(object, a)[object, a] rescue nil
+        next if !attr_method
+
+        args = v.is_a?(Array) ? v : [].push(v)
+        attr_method = curry(attr_method) if required_parameters?(attr_method)
+        if dot_keys.include?(k) # recurse (dotted)
+          args.push({ curry: curry, debug: debug })
+          value = values_at(attr_method.call, *args).first
+        else # final call to the method
+          value = attr_method[*args] # rescue nil
+          puts "value: #{value}" if debug
+        end
+        value = nil if !curry && value.is_a?(Proc)
+        value
+      end
+
+    end
+
+    module Test
+      class A
+        attr_reader :ops, :cops
+        def initialize(val)
+          @ops = val
+        end
+        def mops
+          'm-' + @ops
+        end
+        def cops=(value)
+          @ops = value
+        end
+        def rops(val)
+          @ops + " there we go with '#{val}' !!"
+        end
+        def xops(val, xop:)
+          @ops + " #{val}!! Xops do the trick with '#{xop}'."
+        end
+        private
+        def gops
+          'g+' + @ops
+        end
+      end
+      class B
+        attr_accessor :a, :c
+        def initialize(a)
+          @a = A.new(a)
+        end
+        def c=(value)
+          @c = value
+        end
+        def bofs(v1, v2:)
+          "#{v1} #{v2} with #{@c}"
+        end
+      end
+    end
+
+    def self.test_values_at
+      h = {'pops' => 'aghr!', pops: 5, 'nops' => 'nope!'}
+      a = Test::A.new('hello!')
+      b = Test::B.new('bye')
+      b.c = 'cheese'
+
+      pp Handy.values_at(h, 'nops', :pops)
+      pp Handy.values_at(a, 'rops', 'mops', rops: 'EVERY', xops: ['Dear', xop: 'SOMETHING BETTER'])
+      pp Handy.values_at(a, 'mops', 'gops', rops: 'EVERY THING')
+
+      pp Handy.values_at_dot(b, 'c', 'bofs' => ['stranberry', v2: 'combines'], 'a.rops': 'DOTTED CALL')
+      pp "+" * 60
+      pp Handy.values_at_dot(b, 'c', 'bofs' => ['stranberry', v2: 'combines'], debug: true, 'a.rops': 'DOTTED CALL')
+      pp "+" * 60
+    end
+
+  end
+end