active_enumerable 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b42bdf39bf71038c5874ee160fd48a83a3055d0
-  data.tar.gz: 84c95fda2a65d555b3b25071bfd14f826ea7f198
+  metadata.gz: 016716ccb116b9441ef93f1d0698201c9b41ac50
+  data.tar.gz: a164e13d533c2aa282b9d7663ee65f1a28b8ea17
 SHA512:
-  metadata.gz: 92a9a0c81dd3dbf728b53df5870cd18ad69a7dcc21f36d177e1f5306d161eeadaf3d896645118df068bfded6b14d3d8b05e498b60047bbc74a816189eca588a3
-  data.tar.gz: 40f02181da88f8d49d9ab5df82628907f35c2ba8598628dea895f297274bf36dac553ec671d78aa486e1b798336ed85191eeb905bf273d4222f5c8017236a571
+  metadata.gz: 7ab10d01e6738b89b9f375b1a1df9156f5cf8c2a3f96b026e698f244c232fd73a9188adc3523d678c721bb995b5902620e0b04dc4647c6fb90148e26f3112cb1
+  data.tar.gz: cb3a52fd97b0aae04319d7749e8df84b23fa9b30747cbc54c861f90b9c0d009ee6ba695e6dfb6a4db185fe541999e524ce5d72b86c799afc94a7ebdf4aac4c47

data/README.md

@@ -1,8 +1,6 @@
 # ActiveEnumerable
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/active_enumerable`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Include ActiveRecord like query methods to Ruby enumerable collections.
 
 ## Installation
 
@@ -22,7 +20,33 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+require "active_enumerable"
+
+class Customers
+  include ActiveEnumerable
+  
+  scope :unpaid, -> { where(paid: false).or(credit: 0) }
+end
+
+customers = Customers.new([{paid: true, credit: 1000}, {paid: false, credit: 2000}, {paid: false, credit: 0}])
+
+customers.unpaid
+  # => <#Customers [{:paid=>false, :credit=>2000}, {:paid=>false, :credit=>0}]]>
+  
+customers.scope { select { |y| y > 1000 } }
+  #=> <#Customers [{paid: true, credit: 1000}, {paid: false, credit: 2000}]>
+  
+customers.sum(:credit)
+  #=> 3000
+  
+customers.create({paid: true, credit: 1500}) # defaults to Hash creations
+
+Customers.item_class = Customer
+
+customers.create({paid: true, credit: 1500}).to_a.last
+  #=> <#Customer paid: true, credit: 1500>
+```
 
 ## Development
 
@@ -32,7 +56,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/active_enumerable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/zeisler/active_enumerable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
 
 
 ## License

data/lib/active_enumerable.rb

@@ -1,5 +1,25 @@
 require "active_enumerable/version"
+require "active_enumerable/base"
+require "active_enumerable/comparable"
+require "active_enumerable/enumerable"
+require "active_enumerable/finder"
+require "active_enumerable/method_caller"
+require "active_enumerable/scopes"
+require "active_enumerable/where"
+require "active_enumerable/queries"
 
 module ActiveEnumerable
-  # Your code goes here...
+  include Base
+  include Enumerable
+  include Comparable
+  include Queries
+  include Scopes
+
+  module ClassMethods
+    include Scopes::ClassMethods
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
 end

data/lib/active_enumerable/base.rb

@@ -0,0 +1,44 @@
+module ActiveEnumerable
+  module Base
+    def initialize(collection=[])
+      @to_a = collection.to_ary
+    end
+
+    attr_reader :to_a
+
+    # @private
+    def __new_relation__(collection)
+      self.class.new(collection)
+    end
+
+    def create(attributes)
+      add(if (klass = self.class.item_class)
+            klass.new(attributes)
+          else
+            attributes
+          end)
+    end
+
+    def add(item)
+      to_a << item
+    end
+
+    def all
+      self
+    end
+
+    module ClassMethods
+      def item_class
+        @item_class
+      end
+
+      def item_class=(klass)
+        @item_class = klass
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/active_enumerable/comparable.rb

@@ -0,0 +1,11 @@
+module ActiveEnumerable
+  module Comparable
+    include ::Comparable
+
+    def <=>(anOther)
+      if anOther.is_a?(Array) || self.class == anOther.class
+        to_a <=> anOther.to_a
+      end
+    end
+  end
+end

data/lib/active_enumerable/enumerable.rb

@@ -0,0 +1,9 @@
+module ActiveEnumerable
+  module Enumerable
+    include ::Enumerable
+
+    def each(*args, &block)
+      @to_a.send(:each, *args, &block)
+    end
+  end
+end

data/lib/active_enumerable/finder.rb

@@ -0,0 +1,39 @@
+module ActiveEnumerable
+  # @private
+  class Finder
+    def initialize(record)
+      @method_caller = MethodCaller.new(record)
+    end
+
+    def is_of(conditions={})
+      conditions.all? do |col, match|
+        if match.is_a? Hash
+          hash_match(col, match)
+        elsif match.is_a? ::Enumerable
+          any_match(col, match)
+        else
+          compare(col, match)
+        end
+      end
+    end
+
+    private
+
+    def hash_match(col, match)
+      next_record = @method_caller.call(col)
+      if next_record.is_a? Array
+        next_record.any? { |record| Finder.new(record).is_of(match) }
+      else
+        Finder.new(next_record).is_of(match)
+      end
+    end
+
+    def any_match(col, match)
+      match.any? { |m| compare(col, m) }
+    end
+
+    def compare(col, match)
+      @method_caller.call(col) == match
+    end
+  end
+end

data/lib/active_enumerable/method_caller.rb

@@ -0,0 +1,21 @@
+module ActiveEnumerable
+  # @private
+  class MethodCaller
+    attr_reader :object, :raise_no_method
+
+    def initialize(object, raise_no_method: true)
+      @object          = object
+      @raise_no_method = raise_no_method
+    end
+
+    def call(method)
+      if object.is_a? Hash
+        object.fetch(method)
+      else
+        object.public_send(method)
+      end
+    rescue NoMethodError, KeyError => e
+      raise e if raise_no_method
+    end
+  end
+end

data/lib/active_enumerable/queries.rb

@@ -0,0 +1,234 @@
+module ActiveEnumerable
+  module Queries
+    include ActiveEnumerable::Where
+
+    # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    # If no record can be found for all of the listed ids, then RecordNotFound will be raised. If the primary key
+    # is an integer, find by id coerces its arguments using +to_i+.
+    #
+    #   <#ActiveEnumerable>.find(1)          # returns the object for ID = 1
+    #   <#ActiveEnumerable>.find(1, 2, 6)    # returns an array for objects with IDs in (1, 2, 6)
+    #   <#ActiveEnumerable>.find([7, 17])    # returns an array for objects with IDs in (7, 17)
+    #   <#ActiveEnumerable>.find([1])        # returns an array for the object with ID = 1
+    #
+    # <tt>ActiveEnumerable::RecordNotFound</tt> will be raised if one or more ids are not found.
+    def find(ids)
+      raise RecordNotFound.new("Couldn't find #{self.name} without an ID") if ids.nil?
+      results = [*ids].map do |id|
+        find_by!(id: id.to_i)
+      end
+      return __new_relation__(results) if ids.class == Array
+      results.first
+    end
+
+    # Updates all records with details given if they match a set of conditions supplied, limits and order can
+    # also be supplied.
+    #
+    # ==== Parameters
+    #
+    # * +updates+ - A string, array, or hash.
+    #
+    # ==== Examples
+    #
+    #   # Update all customers with the given attributes
+    #   <#ActiveEnumerable>.update_all wants_email: true
+    #
+    #   # Update all books with 'Rails' in their title
+    #   <#ActiveEnumerable>.where(title: 'Rails').update_all(author: 'David')
+    #
+    #   # Update all books that match conditions, but limit it to 5 ordered by date
+    #   <#ActiveEnumerable>.where(title: 'Rails').order(:created_at).limit(5).update_all(author: 'David')
+    def update_all(attributes)
+      all.each { |i| i.update(attributes) }
+    end
+
+    # Updates an object (or multiple objects) and saves it.
+    #
+    # ==== Parameters
+    #
+    # * +id+ - This should be the id or an array of ids to be updated.
+    # * +attributes+ - This should be a hash of attributes or an array of hashes.
+    #
+    # ==== Examples
+    #
+    #   # Updates one record
+    #   <#ActiveEnumerable>.update(15, user_name: 'Samuel', group: 'expert')
+    #
+    #   # Updates multiple records
+    #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
+    #   <#ActiveEnumerable>.update(people.keys, people.values)
+    def update(id, attributes)
+      if id.is_a?(Array)
+        id.map.with_index { |one_id, idx| update(one_id, attributes[idx]) }
+      else
+        object = find(id)
+        object.update(attributes)
+        object
+      end
+    end
+
+    # Finds the first record matching the specified conditions. There
+    # is no implied ordering so if order matters, you should specify it
+    # yourself.
+    #
+    # If no record is found, returns <tt>nil</tt>.
+    #
+    #   <#ActiveEnumerable>.find_by name: 'Spartacus', rating: 4
+    def find_by(conditions = {})
+      to_a.detect do |record|
+        Finder.new(record).is_of(conditions)
+      end
+    end
+
+    # Like <tt>find_by</tt>, except that if no record is found, raises
+    # an <tt>ActiveEnumerable::RecordNotFound</tt> error.
+    def find_by!(conditions={})
+      result = find_by(conditions)
+      if result.nil?
+        raise RecordNotFound.new("Couldn't find #{self.name} with '#{conditions.keys.first}'=#{conditions.values.first}")
+      end
+      result
+    end
+
+    # Finds the first record with the given attributes, or creates a record
+    # with the attributes if one is not found:
+    #
+    #   # Find the first user named "Penélope" or create a new one.
+    #   <#ActiveEnumerable>.find_or_create_by(first_name: 'Penélope')
+    #   # => #<User id: 1, first_name: "Penélope", last_name: nil>
+    #
+    #   # Find the first user named "Penélope" or create a new one.
+    #   # We already have one so the existing record will be returned.
+    #   <#ActiveEnumerable>.find_or_create_by(first_name: 'Penélope')
+    #   # => #<User id: 1, first_name: "Penélope", last_name: nil>
+    #
+    # This method accepts a block, which is passed down to +create+. The last example
+    # above can be alternatively written this way:
+    #
+    #   # Find the first user named "Scarlett" or create a new one with a
+    #   # different last name.
+    #   <#ActiveEnumerable>.find_or_create_by(first_name: 'Scarlett') do |user|
+    #     user.last_name = 'Johansson'
+    #   end
+    #   # => #<User id: 2, first_name: "Scarlett", last_name: "Johansson">
+    #
+    def find_or_create_by(attributes, &block)
+      find_by(attributes) || create(attributes, &block)
+    end
+
+    alias_method :find_or_create_by!, :find_or_create_by
+
+    # Like <tt>find_or_create_by</tt>, but calls <tt>new</tt> instead of <tt>create</tt>.
+    def find_or_initialize_by(attributes, &block)
+      find_by(attributes) || new(attributes, &block)
+    end
+
+    # Count the records.
+    #
+    #   <#ActiveEnumerable>.count
+    #   # => the total count of all people
+    #
+    #   <#ActiveEnumerable>.count(:age)
+    #   # => returns the total count of all people whose age is not nil
+    def count(name = nil)
+      return all.size if name.nil?
+      where.not(name => nil).size
+    end
+
+    # Specifies a limit for the number of records to retrieve.
+    #
+    #   <#ActiveEnumerable>.limit(10)
+    def limit(num)
+      relation = __new_relation__(all.take(num))
+      relation.send(:set_from_limit)
+      relation
+    end
+
+    # Calculates the sum of values on a given attribute. The value is returned
+    # with the same data type of the attribute, 0 if there's no row.
+    #
+    #   <#ActiveEnumerable>.sum(:age) # => 4562
+    def sum(key)
+      values = values_by_key(key)
+      values.inject(0) do |sum, n|
+        sum + (n || 0)
+      end
+    end
+
+    # Calculates the average value on a given attribute. Returns +nil+ if there's
+    # no row.
+    #
+    #   <#ActiveEnumerable>.average(:age) # => 35.8
+    def average(key)
+      values = values_by_key(key)
+      total  = values.inject { |sum, n| sum + n }
+      BigDecimal.new(total) / BigDecimal.new(values.count)
+    end
+
+    # Calculates the minimum value on a given attribute. The value is returned
+    # with the same data type of the attribute, or +nil+ if there's no row.
+    #
+    #   <#ActiveEnumerable>.minimum(:age) # => 7
+    def minimum(key)
+      values_by_key(key).min_by { |i| i }
+    end
+
+    # Calculates the maximum value on a given attribute. The value is returned
+    # with the same data type of the attribute, or +nil+ if there's no row.
+    #
+    #   <#ActiveEnumerable>.maximum(:age) # => 93
+    def maximum(key)
+      values_by_key(key).max_by { |i| i }
+    end
+
+    # Allows to specify an order attribute:
+    #
+    #   <#ActiveEnumerable>.order('name')
+    #
+    #   <#ActiveEnumerable>.order(:name)
+    def order(key)
+      __new_relation__(all.sort_by { |item| MethodCaller.new(item).call(key) })
+    end
+
+    # Reverse the existing order clause on the relation.
+    #
+    #   <#ActiveEnumerable>.order('name').reverse_order
+    def reverse_order
+      __new_relation__(to_a.reverse)
+    end
+
+    # Returns a chainable relation with zero records.
+    #
+    # Any subsequent condition chained to the returned relation will continue
+    # generating an empty relation.
+    #
+    # Used in cases where a method or scope could return zero records but the
+    # result needs to be chainable.
+    #
+    # For example:
+    #
+    #   @posts = current_user.visible_posts.where(name: params[:name])
+    #   # => the visible_posts method is expected to return a chainable Relation
+    #
+    #   def visible_posts
+    #     case role
+    #     when 'Country Manager'
+    #       <#ActiveEnumerable>.where(country: country)
+    #     when 'Reviewer'
+    #       <#ActiveEnumerable>.published
+    #     when 'Bad User'
+    #       <#ActiveEnumerable>.none # It can't be chained if [] is returned.
+    #     end
+    #   end
+    #
+    def none
+      __new_relation__([])
+    end
+
+    private
+
+    def values_by_key(key)
+      all.map { |obj| obj.send(key) }
+    end
+  end
+end

data/lib/active_enumerable/record_not_found.rb

@@ -0,0 +1,4 @@
+module ActiveEnumerable
+  class RecordNotFound < StandardError
+  end
+end

data/lib/active_enumerable/scopes.rb

@@ -0,0 +1,52 @@
+module ActiveEnumerable
+  module Scopes
+    def method_missing(meth, *args, &block)
+      if create_scope_method(meth)
+        send(meth, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth, include_private = false)
+      if create_scope_method(meth)
+        true
+      else
+        super
+      end
+    end
+
+    def create_scope_method(meth)
+      if (scope = self.class.__scoped_methods__.find { |a| a.first == meth })
+        self.define_singleton_method(scope.first) do
+          scope(&scope.last)
+        end
+      end
+    end
+
+    def scope(&block)
+      result = instance_exec(&block)
+      if result.is_a? Array
+        __new_relation__(result)
+      else
+        result
+      end
+    end
+
+    private :create_scope_method
+
+    module ClassMethods
+      def scope(name, block)
+        __scoped_methods__ << [name, block]
+      end
+
+      def __scoped_methods__
+        @__scoped_methods__ ||= []
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/active_enumerable/version.rb

@@ -1,3 +1,3 @@
 module ActiveEnumerable
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/active_enumerable/where.rb

@@ -0,0 +1,99 @@
+module ActiveEnumerable
+  module Where
+    class WhereNotChain
+      def initialize(collection, parent_class)
+        @collection   = collection
+        @parent_class = parent_class
+      end
+
+      # Returns a new relation expressing WHERE + NOT condition according to
+      # the conditions in the arguments.
+      #
+      # #not accepts conditions as a string, array, or hash. See Where#where for
+      # more details on each format.
+      #
+      #    <#ActiveEnumerable>.where.not(name: "Jon")
+      #    <#ActiveEnumerable>.where.not(name: nil)
+      #    <#ActiveEnumerable>.where.not(name: %w(Ko1 Nobu))
+      #    <#ActiveEnumerable>.where.not(name: "Jon", role: "admin")
+      def not(conditions={})
+        @parent_class.call(@collection.reject do |record|
+          Finder.new(record).is_of(conditions)
+        end)
+      end
+    end
+
+    # Returns a new relation, which is the result of filtering the current relation
+    # according to the conditions in the arguments.
+    #
+    # === hash
+    #
+    # #where will accept a hash condition, in which the keys are fields and the values
+    # are values to be searched for.
+    #
+    # Fields can be symbols or strings. Values can be single values, arrays, or ranges.
+    #
+    #    <#ActiveEnumerable>.where({ name: "Joe", email: "joe@example.com" })
+    #
+    #    <#ActiveEnumerable>.where({ name: ["Alice", "Bob"]})
+    #
+    #    <#ActiveEnumerable>.where({ created_at: (Time.now.midnight - 1.day)..Time.now.midnight })
+    #
+    #    <#ActiveEnumerable>.where(contracts:[{ created_at: (Time.now.midnight - 1.day)..Time.now.midnight }])
+    #
+    # .or
+    #
+    # Returns a new relation, which is the logical union of this relation and the one passed as an
+    # argument.
+    #
+    # The two relations must be structurally compatible: they must be scoping the same model, and
+    # they must differ only by #where.
+    #
+    #    <#ActiveEnumerable>.where(id: 1).or(<#ActiveEnumerable>.where(author_id: 3))
+    #
+    # Additional conditions can be passed to where in hash form.
+    #
+    #   <#ActiveEnumerable>.where(id: 1).or(author_id: 3)
+    #
+    def where(conditions=nil)
+      return WhereNotChain.new(all, method(:__new_relation__)) if conditions.nil?
+      enable_or create_where_relation(conditions, to_a.select do |record|
+        Finder.new(record).is_of(conditions)
+      end)
+    end
+
+    def enable_or(relation)
+      pre_where_to_a = to_a
+      relation.define_singleton_method(:or) do |conditions_or_relation|
+        conditions = get_conditions(conditions_or_relation)
+        or_result = create_where_relation(where_conditions, pre_where_to_a).where(conditions)
+        create_where_relation(or_result.where_conditions, relation.to_a.concat(or_result.to_a).uniq)
+      end
+      relation
+    end
+
+    private :enable_or
+
+    def get_conditions(conditions_or_relation)
+      if conditions_or_relation.respond_to?(:where_conditions)
+        conditions_or_relation.where_conditions
+      else
+        conditions_or_relation
+      end
+    end
+
+    private :get_conditions
+
+    def where_conditions
+      @where_conditions ||= {}
+    end
+
+    def create_where_relation(conditions, array)
+      nr = __new_relation__(array)
+      nr.where_conditions.merge!(conditions)
+      nr
+    end
+
+    private :create_where_relation
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_enumerable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-01 00:00:00.000000000 Z
+date: 2016-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,7 +72,16 @@ files:
 - bin/console
 - bin/setup
 - lib/active_enumerable.rb
+- lib/active_enumerable/base.rb
+- lib/active_enumerable/comparable.rb
+- lib/active_enumerable/enumerable.rb
+- lib/active_enumerable/finder.rb
+- lib/active_enumerable/method_caller.rb
+- lib/active_enumerable/queries.rb
+- lib/active_enumerable/record_not_found.rb
+- lib/active_enumerable/scopes.rb
 - lib/active_enumerable/version.rb
+- lib/active_enumerable/where.rb
 homepage: https://github.com/zeisler/active_enumerable
 licenses:
 - MIT
@@ -93,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Gives ActiveRecord like querying methods to ruby enumerable objects.