uber_array 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5eaa7aae77cd713169e5148fc0b5d7d4deffe6b1
+  data.tar.gz: 1dcb67cd4983d0fca9186a699feac341419e5d09
+SHA512:
+  metadata.gz: eb67ba7fd12560804a0fb645c6ca31ede7127bfbc14e47f6dc0cc7442327579c9c3035019a94924a0f453d693a6f9a63e81b33102a3ec56a32295a67ee9da87d
+  data.tar.gz: aef965890618882796892310279d59bab15774c8dd97a3b66ba1fb4979bc873e975cb9e58f79718a0117a0ec20e160df869c13892a4073550cb3408039bf84d6

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.log
+*.rbc
+.bundle
+.config
+.rvmrc
+.yardoc
+Gemfile.lock
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+temp
+tmp
+vendor

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,57 @@
+AllCops:
+  Excludes:
+    - temp/*
+
+Encoding:
+  Enabled: false
+
+AmbiguousOperator:
+  Enabled: false
+
+CaseIndentation:
+  Enabled: false
+
+CyclomaticComplexity:
+  Enabled: false
+  Max: 10
+
+PerceivedComplexity:
+  Enabled: false
+  Max: 10
+
+Documentation:
+  Enabled: false
+
+EmptyLinesAroundBody:
+  Enabled: false
+
+HashSyntax:
+  Enabled: false
+
+ClassLength:
+  Enabled: false
+
+LineLength:
+  Enabled: true
+  Max: 160
+
+MethodLength:
+  Enabled: false
+
+ModuleFunction:
+  Enabled: false
+
+NestedTernaryOperator:
+  Enabled: false
+
+RaiseArgs:
+  Enabled: false
+
+RescueModifier:
+  Enabled: false
+
+SymbolProc:
+  Enabled: false
+
+UnusedMethodArgument:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+### [0.1.0] - 2016-11-12
+* Initial version

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2015, Opower
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,71 @@
+#uber_array
+
+`UberArray` is an `Array` based datatype that enables SQL-like `where` syntax for arrays of Hashes or Objects.
+
+In Hash based arrays each element is a Hash with symbols or strings as keys.
+In Object based arrays each element is an Object-derived instance that responds to attribute names instead of keys.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'uber_array'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install uber_array
+
+## Usage
+
+```ruby
+require 'uber_array'
+
+# Array of Hash elements with strings as keys
+items = [
+  { 'name' => 'Jack', 'score' => 999, 'active' => false },
+  { 'name' => 'Jake', 'score' => 888, 'active' => true  },
+  { 'name' => 'John', 'score' => 777, 'active' => true  }
+]
+
+uber_items = UberArray.new(items)
+
+uber_items.where('name' => 'John')
+uber_items.where('name' => /Ja/i)
+uber_items.like('ja')
+uber_items.where('name' => %w(Dave John Tom))
+uber_items.where('score' => 999)
+uber_items.where('score' => ->(s){s > 900})
+uber_items.where('active' => true, 'score' => 800..900)
+uber_items.map_by('name')
+
+Player = Struct.new(:name, :score, :active)
+
+# Array of Object-like Struct elements with attributes
+objs = [
+  Player.new('Jack', 999, false),
+  Player.new('Jake', 888, true),
+  Player.new('John', 777, true)
+]
+
+uber_objs = UberArray.new(objs, :primary_key => :__name__)
+
+uber_objs.where(:__name__ => 'John')
+uber_objs.where(:__name__ => /Ja/i)
+uber_objs.like('ja')
+uber_objs.where(:__name__ => %w(Dave John Tom))
+uber_objs.where(:__score__ => 999)
+uber_objs.where(:__score__ => ->(s){s > 900})
+uber_objs.where(:__active__ => true, :__score__ => 800..900)
+```
+
+### Contributing
+
+1. Fork it
+2. Create your feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin my-new-feature)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/*_spec.rb'
+end
+
+task :default => :spec

data/lib/uber_array.rb

@@ -0,0 +1,130 @@
+class UberArray
+  attr_accessor :array, :primary_key
+
+  # @param array [Array<Hash|Object>] underlying array
+  # @param options [Hash] init options
+  # @option options [String|Symbol] :primary_key Name of primary key or attribute
+  #   attribute/method names are specified as symbols like :__name__
+  def initialize(array = [], options = {})
+    @array = array || []
+    @primary_key = options[:primary_key] || 'name'
+  end
+
+  # get current config options
+  def uberopts
+    { primary_key: primary_key }
+  end
+
+  # delegate all methods to the inner @array,
+  # if the result is an Array with elements of the same type as @array - convert it to UberArray
+  def method_missing(method, *args, &block)
+    klass = @array.first.class
+    result = @array.send(method, *args, &block)
+    if result.is_a?(Array)
+      @array.empty? || result.empty? || result.first.class == klass ? UberArray.new(result, uberopts) : result
+    else
+      result
+    end
+  end
+
+  # @param key [String|Symbol] key name to map by
+  def map_by(key)
+    @array.map { |i| i[key] }
+  end
+
+  # build a Proc by which to filter items in @array
+  # @params opts [Hash] filter options
+  def filter_proc(opts = {})
+    fail ArgumentError, 'Hash argument expected' unless opts.is_a?(Hash)
+
+    if opts.empty?
+      -> { false }
+    else
+      lambda do |item|
+        opts.map do |key, val|
+          can_respond, ival = item_send_if_respond_to?(item, key)
+          can_respond &&
+          case val
+          # :key => ->(v){v > 12}
+          when Proc
+            val.call(ival)
+          # :key => /text/
+          when Regexp
+            ival =~ val
+          # :key => 1..4, :key => [1,2,3,4]
+          when Array, Range
+            val.to_a.include?(ival)
+          # :key => false|true, :key => 'text', :key => 10
+          else
+            ival == val
+          end
+        end.all?
+      end
+    end
+  end
+
+  # check if key represents a method/attribute name and return it if so
+  # @param key [String|Symbol] key name
+  def method_name?(key)
+    key.is_a?(Symbol) && /^__(?<name>.+)__$/ =~ key ? name.to_sym : nil
+  end
+
+  # check if item responds to a given key/attribute name
+  def item_respond_to?(item, key)
+    method = method_name?(key) || :[]
+    item.respond_to?(method)
+  end
+
+  # invoke the given key/attribute name as a method on item
+  def item_send(item, key)
+    method = method_name?(key)
+    method ? item.send(method) : item[key]
+  end
+
+  # send a key/method name to an item if the item responds to it
+  # @param item [Hash|Object] item of @array
+  # @param key [String|Symbol] key name
+  def item_send_if_respond_to?(item, key)
+    can_respond, result = nil, nil
+    method = method_name?(key)
+    if method
+      can_respond = item.respond_to?(method)
+      result = item.send(method) if can_respond
+    else
+      can_respond = item.respond_to?(:[])
+      result = item[key] if can_respond
+    end
+    [can_respond, result]
+  end
+
+  # filter items in @array
+  # @params opts [Hash] filter options
+  # Keys are key names (e.g. :name, 'name') for Hash-based elements
+  # or attribute names (e.g. :__name__) for Object-based elements
+  def where(opts = {})
+    return UberArray.new([], uberopts) if opts.empty?
+    result = @array.select(&filter_proc(opts))
+    UberArray.new(result, uberopts)
+  end
+  alias_method :filter, :where
+
+  # filter items by regex matching on @primary_key
+  def like(regex)
+    exp = regex.is_a?(String) ? Regexp.new(regex, true) : regex
+    where(primary_key => exp)
+  end
+
+  # use a non-number as access key into @array
+  # with elements responding to a key or attribute name specified by @primary_key
+  def [](key)
+    return @array[key] if key.is_a?(Fixnum)
+    method = method_name?(primary_key)
+    @array.find do |item|
+      if method
+        item.respond_to?(method) && item.send(method) == key
+      else
+        item.respond_to?(:[]) && item[primary_key] == key
+      end
+    end
+  end
+end

data/lib/uber_array/version.rb

@@ -0,0 +1,3 @@
+class UberArray
+  VERSION = '0.1.0'
+end

data/spec/fixtures/items.yml

@@ -0,0 +1,55 @@
+---
+- id:    0a
+  name:  John Doe
+  team:  ninjas
+  score: 800
+  email: john.doe@test.com
+  phone:
+    voice: 1234
+    sms:   6789
+  admin:  false
+  active: true
+
+- id:    1b
+  name:  Jim Black
+  team:  punks
+  score: 900
+  email: jim.black@ping.me
+  phone:
+    voice: 2345
+    sms:   5678
+  admin:  false
+  active: false
+
+- id:    2c
+  name:  Anne Kim
+  team:  sisters
+  score: 678
+  email: anne@sista.net
+  phone:
+    voice:
+    sms:
+  admin:  false
+  active: true
+
+- id:    3d
+  name:  Sandi
+  team:  sisters
+  score: 555
+  email: sandi@sista.net
+  phone:
+    voice: 2222
+    sms:
+  admin:  false
+  active: false
+
+- id:    4e
+  name:  Zak
+  team:  ninjas
+  score: 999
+  email: captain@test.me
+  phone:
+    voice: 7777
+    sms:
+  admin:  true
+  active: true

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rspec'
+require 'yaml'
+require 'uber_array'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  def load_fixtures
+    file = '../fixtures/items.yml'
+    YAML.load_file(File.expand_path(file, __FILE__))
+  end
+end

data/spec/uber_array_spec.rb

@@ -0,0 +1,200 @@
+module UberArraySpec
+
+  class Item
+    def initialize(options = {})
+      options.each do |key, val|
+        instance_variable_set("@#{key}", val)
+        self.class.send(:attr_reader, key.to_sym)
+      end
+    end
+  end
+
+  describe UberArray do
+    # each array element is a Hash with string key names
+    let(:items_str) { load_fixtures }
+    # each array element is a Hash with symbolized key names
+    let(:items_sym) { items_str.map { |i| Hash[i.map { |(k, v)| [k.to_sym, v] }] } }
+    # each array element is an Item object with attributes instead of key names
+    let(:items_obj) { items_str.map { |i| Item.new(i) } }
+
+    # UberArray instances
+    subject(:array_sym) { UberArray.new(items_sym) }
+    subject(:array_str) { UberArray.new(items_str) }
+    subject(:array_obj) { UberArray.new(items_obj) }
+
+    let(:names) { items_sym.map { |i| i[:name] } }
+    let(:name)  { 'Sandi' }
+
+    it 'delegates to the inner Array' do
+      expect(array_sym.respond_to?(:size)).to be false
+      expect(array_sym.size).to eq(5)
+    end
+
+    it 'returns an UberArray when resulting elements are of the same type' do
+      expect(array_str.reverse).to be_a UberArray
+      expect(array_sym.sample(2)).to be_a UberArray
+      expect(array_sym.select { |i| i[:active] }).to be_a UberArray
+      expect(array_obj.select { |i| i.active }).to be_a UberArray
+    end
+
+    it 'returns a regular Array when resulting elements are of a different type' do
+      expect(array_str.map { |i| Item.new(i) }).not_to be_a UberArray
+    end
+
+    describe '#method_name?' do
+      it 'extracts method name' do
+        [
+          # input_key => result
+          [:__name__, :name],
+          [:___name___, :_name_],
+          [:_name_, nil],
+          ['__name__', nil]
+        ].each { |key, rez| expect(array_sym.method_name?(key)).to eq rez }
+      end
+    end
+
+    describe '#map_by' do
+      it 'maps by string' do
+        expect(array_str.map_by('name')).to eq names
+      end
+
+      it 'maps by symbol' do
+        expect(array_sym.map_by(:name)).to eq names
+      end
+
+      it 'maps by attribute name' do
+        expect(array_obj.map(&:name)).to eq names
+      end
+    end
+
+    describe '#where' do
+      it 'filters by {string => String}' do
+        # where item['name'] equals name
+        expect(array_str.where('name' => name).array).to eq items_str.values_at(3)
+        expect(array_sym.where('name' => name).array).to be_empty
+        expect(array_obj.where('name' => name).array).to be_empty
+      end
+
+      it 'filters by {:symbol => String}' do
+        # where item['name'] equals name
+        expect(array_str.where(:name => name).array).to be_empty
+        expect(array_sym.where(:name => name).array).to eq items_sym.values_at(3)
+        expect(array_obj.where(:name => name).array).to be_empty
+      end
+
+      it 'filters by {:__symbol__ => String}' do
+        # where item.name equals name
+        expect(array_str.where(:__name__ => name).array).to be_empty
+        expect(array_sym.where(:__name__ => name).array).to be_empty
+        expect(array_obj.where(:__name__ => name).array).to eq items_obj.values_at(3)
+      end
+
+      it 'filters by {key => Regexp}' do
+        regex = /test/
+        # where item['email'] is like regex
+        expect(array_str.where('email' => regex).array).to eq items_str.values_at(0, 4)
+        expect(array_sym.where(:email  => regex).array).to eq items_sym.values_at(0, 4)
+        expect(array_obj.where(:__email__ => regex).array).to eq items_obj.values_at(0, 4)
+      end
+
+      it 'filters by {key => Boolean}' do
+        # where item['admin'] is true
+        expect(array_str.where('admin' => true).array).to eq items_str.values_at(4)
+        expect(array_sym.where(:admin  => true).array).to eq items_sym.values_at(4)
+        expect(array_obj.where(:__admin__ => true).array).to eq items_obj.values_at(4)
+        # where item['active'] is false
+        expect(array_str.where('active' => false).array).to eq items_str.values_at(1, 3)
+        expect(array_sym.where(:active  => false).array).to eq items_sym.values_at(1, 3)
+        expect(array_obj.where(:__active__ => false).array).to eq items_obj.values_at(1, 3)
+      end
+
+      it 'filters by {key => Proc}' do
+        prok = ->(score) { score > 900 }
+        # where item['score'] < 900
+        expect(array_str.where('score' => prok).array).to eq items_str.values_at(4)
+        expect(array_sym.where(:score  => prok).array).to eq items_sym.values_at(4)
+        expect(array_obj.where(:__score__ => prok).array).to eq items_obj.values_at(4)
+      end
+
+      it 'filters by {key => Range}' do
+        range = 500..700
+        # where item['score'] is in range
+        expect(array_str.where('score' => range).array).to eq items_str.values_at(2, 3)
+        expect(array_sym.where(:score  => range).array).to eq items_sym.values_at(2, 3)
+        expect(array_obj.where(:__score__ => range).array).to eq items_obj.values_at(2, 3)
+      end
+
+      it 'filters by {key => Array}' do
+        teams = %w(bots ninjas)
+        # where item['team'] is a member of teams
+        expect(array_str.where('team' => teams).array).to eq items_str.values_at(0, 4)
+        expect(array_sym.where(:team  => teams).array).to eq items_sym.values_at(0, 4)
+        expect(array_obj.where(:__team__ => teams).array).to eq items_obj.values_at(0, 4)
+      end
+
+      it 'filters by multiple criteria' do
+        # where item['active'] is true AND item['score'] < 700
+        filter = { 'active' => true, 'score' => ->(s) { s < 700 } }
+        expect(array_str.where(filter).array).to eq items_str.values_at(2)
+        # where item[:team] equals team AND item[:admin] is true
+        filter = { :team => 'ninjas', :admin => true }
+        expect(array_sym.where(filter).array).to eq items_sym.values_at(4)
+        # where item.email is like regex AND item.phone['sms'] is not nil
+        filter = { :__email__ => /test/, :__phone__ => ->p { p['sms'] } }
+        expect(array_obj.where(filter).array).to eq items_obj.values_at(0)
+      end
+
+      it 'supports chaining' do
+        team = 'ninjas'
+        expect(array_sym.where(active: true).where(team: team).array).to eq items_sym.values_at(0, 4)
+      end
+    end
+
+    describe '#like' do
+      it 'filters by regex matching on primary_key' do
+        ['an', /an/i].each do |regex|
+          # where item['name'] =~ regex
+          expect(array_str.like(regex).array).to eq items_str.values_at(2, 3)
+        end
+      end
+    end
+
+    describe '#[]' do
+      it 'references elements by index' do
+        expect(array_str[1]).to eq items_str[1]
+      end
+
+      it "references items by the value of primary_key 'name'" do
+        # primary_key is a string key 'name' by default
+        expect(array_str[name]).to eq array_str[3]
+        expect(array_sym[name]).to eq nil
+        expect(array_obj[name]).to eq nil
+      end
+
+      it 'references items by the value of primary_key :name' do
+        # primary_key is a symbol key :name
+        [array_str, array_sym, array_obj].each { |a| a.primary_key = :name }
+        expect(array_str[name]).to eq nil
+        expect(array_sym[name]).to eq array_sym[3]
+        expect(array_obj[name]).to eq nil
+      end
+
+      it 'references items by the value of primary_key :__name__' do
+        # primary_key is an attribute :__name__
+        [array_str, array_sym, array_obj].each { |a| a.primary_key = :__name__ }
+        expect(array_str[name]).to eq nil
+        expect(array_sym[name]).to eq nil
+        expect(array_obj[name]).to eq array_obj[3]
+      end
+
+      it 'references items by the value of primary_key :id' do
+        id = '3d'
+        # primary_key is a symbol key :id
+        [array_str, array_sym, array_obj].each { |a| a.primary_key = :id }
+        expect(array_str[id]).to eq nil
+        expect(array_sym[id]).to eq array_sym[3]
+        expect(array_obj[id]).to eq nil
+      end
+    end
+  end
+end

data/uber_array.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/uber_array/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'uber_array'
+  spec.version       = UberArray::VERSION
+  spec.summary       = 'Array based datatype with SQL-like syntax'
+  spec.description   = "Enables SQL-like 'where' syntax for arrays of Hashes or Objects"
+  spec.homepage      = 'https://github.com/alpinweis/uber_array'
+
+  spec.authors       = ['Adrian Kazaku']
+  spec.email         = ['alpinweis@gmail.com']
+
+  spec.license       = 'Apache-2.0'
+
+  spec.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'rake', '~> 10.1'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  # spec.add_development_dependency 'rubocop', '= 0.26.1'
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: uber_array
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adrian Kazaku
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Enables SQL-like 'where' syntax for arrays of Hashes or Objects
+email:
+- alpinweis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/uber_array.rb
+- lib/uber_array/version.rb
+- spec/fixtures/items.yml
+- spec/spec_helper.rb
+- spec/uber_array_spec.rb
+- uber_array.gemspec
+homepage: https://github.com/alpinweis/uber_array
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Array based datatype with SQL-like syntax
+test_files:
+- spec/fixtures/items.yml
+- spec/spec_helper.rb
+- spec/uber_array_spec.rb