airrel 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b961c23489f4318b5feaceb9dd0b278a402ae3361a7516b4f7f5c7514459843
-  data.tar.gz: 5635e4654a366fec1e9aff98394d99675dba861d8514845fbf75cd64ac88ba53
+  metadata.gz: 6db8b37d78ff312a990135ce202982f4e171295e298c23a538f9c6561b899979
+  data.tar.gz: df005dbf7fd3259b3947a372e974bebe67712e06df2cbefd0829e8d82f011adf
 SHA512:
-  metadata.gz: 0cd6592f458ad4aa04a3d43dcbf6d9fe737a9a10a8998b6efa9bc268bd119fa35e0303a8a76a9343007967111a8033fe6762228e966939d7ac97b944772a43a7
-  data.tar.gz: e406cf4797e68a2ee05765bf67cc0cd7900cfddb70d7530e88bbe17ee1dd62c1cc0c29fd2a89a80e6aa7838763f5882a5f073b7811f3e27c5b923ed7d56c2f21
+  metadata.gz: ad00efa854c772d5ca66d5a7eae1d80ac382fe2c3bfd17f7ced82e253991433442ae36c28ccde1144d165314883d7db032f054e03368575ec8ffa563d7674311
+  data.tar.gz: 54124653722d4d3fb13e0d2c5b4e9f892a7e8dda909e6bfdb1a9f542efbf792fa626d3c8ece35a57c89a18e7623b3182044d7fff39defda7387c7c90e3ba41c2

data/examples/demo.rb

@@ -16,10 +16,10 @@ end
 # basic chaining
 puts "=== basic chaining ==="
 relation = Airrel::Relation.new(User)
-  .where(role: "admin")
-  .where(active: true)
-  .order(created_at: :desc)
-  .limit(10)
+                           .where(role: "admin")
+                           .where(active: true)
+                           .order(created_at: :desc)
+                           .limit(10)
 
 puts relation.to_airtable
 puts
@@ -28,7 +28,7 @@ puts
 puts "=== hash to formula ==="
 puts Airrel::FormulaBuilder.hash_to_formula(email: "test@example.com", age: 25)
 puts Airrel::FormulaBuilder.hash_to_formula(age: 18..65)
-puts Airrel::FormulaBuilder.hash_to_formula(role: ["admin", "moderator"])
+puts Airrel::FormulaBuilder.hash_to_formula(role: %w[admin moderator])
 puts Airrel::FormulaBuilder.hash_to_formula(deleted_at: nil)
 puts
 

data/lib/airrel/formula_builder.rb

@@ -10,7 +10,7 @@ module Airrel
         build_predicate(field_name, value)
       end
 
-      formulas.size == 1 ? formulas.first : "AND(#{formulas.join(', ')})"
+      formulas.size == 1 ? formulas.first : "AND(#{formulas.join(", ")})"
     end
 
     def build_predicate(field, value)
@@ -34,7 +34,7 @@ module Airrel
       when Array
         # IN query - use OR
         or_conditions = value.map { |v| build_predicate(field, v) }
-        "OR(#{or_conditions.join(', ')})"
+        "OR(#{or_conditions.join(", ")})"
       else
         # fallback - convert to string and escape
         "{#{field}} = #{escape_string(value.to_s)}"
@@ -46,7 +46,7 @@ module Airrel
     # so we need to escape backslashes first, then quotes
     def escape_string(str)
       # escape backslashes first (\ -> \\), then quotes (' -> \', " -> \")
-      escaped = str.to_s.gsub('\\', '\\\\\\\\').gsub(/['"]/, '\\\\\0')
+      escaped = str.to_s.gsub("\\", "\\\\\\\\").gsub(/['"]/, '\\\\\0')
       "'#{escaped}'"
     end
 
@@ -70,62 +70,34 @@ module Airrel
 
     # helper methods for building formulas programmatically
 
-    def all(*formulas)
-      "AND(#{formulas.join(', ')})"
-    end
+    def all(*formulas) = "AND(#{formulas.join(", ")})"
 
-    def any(*formulas)
-      "OR(#{formulas.join(', ')})"
-    end
+    def any(*formulas) = "OR(#{formulas.join(", ")})"
 
-    def none(formula)
-      "NOT(#{formula})"
-    end
+    def none(formula) = "NOT(#{formula})"
 
-    def eq(field, value)
-      build_predicate(field, value)
-    end
+    def eq(field, value) = build_predicate(field, value)
 
-    def neq(field, value)
-      none(eq(field, value))
-    end
+    def neq(field, value) = none(eq(field, value))
 
-    def gt(field, value)
-      "{#{field}} > #{value}"
-    end
+    def gt(field, value) = "{#{field}} > #{value}"
 
-    def gte(field, value)
-      "{#{field}} >= #{value}"
-    end
+    def gte(field, value) = "{#{field}} >= #{value}"
 
-    def lt(field, value)
-      "{#{field}} < #{value}"
-    end
+    def lt(field, value) = "{#{field}} < #{value}"
 
-    def lte(field, value)
-      "{#{field}} <= #{value}"
-    end
+    def lte(field, value) = "{#{field}} <= #{value}"
 
-    def blank(field)
-      "{#{field}} = BLANK()"
-    end
+    def blank(field) = "{#{field}} = BLANK()"
 
-    def present(field)
-      none(blank(field))
-    end
+    def present(field) = none(blank(field))
 
-    def find(field, search_string)
-      "FIND(#{escape_string(search_string)}, {#{field}})"
-    end
+    def find(field, search_string) = "FIND(#{escape_string(search_string)}, {#{field}})"
 
-    def search(field, search_string)
-      "SEARCH(#{escape_string(search_string)}, {#{field}})"
-    end
+    def search(field, search_string) = "SEARCH(#{escape_string(search_string)}, {#{field}})"
 
     # for multi-select fields (checks if array contains value)
-    def contains(field, value)
-      "FIND(#{escape_string(value.to_s)}, {#{field}})"
-    end
+    def contains(field, value) = "FIND(#{escape_string(value.to_s)}, {#{field}})"
 
     # check if multi-select contains ANY of the values
     def contains_any(field, *values)

data/lib/airrel/relation.rb

@@ -17,46 +17,36 @@ module Airrel
     end
 
     # chaining methods (return new relations)
-    
-    def where(conditions)
-      spawn.where!(conditions)
-    end
+
+    def where(conditions) = spawn.where!(conditions)
 
     def where!(conditions)
       @where_clause = @where_clause.merge(conditions)
       self
     end
 
-    def order(*args)
-      spawn.order!(*args)
-    end
+    def order(*args) = spawn.order!(*args)
 
     def order!(*args)
       @order_values += parse_order_args(args)
       self
     end
 
-    def limit(value)
-      spawn.limit!(value)
-    end
+    def limit(value) = spawn.limit!(value)
 
     def limit!(value)
       @limit_value = value
       self
     end
 
-    def offset(value)
-      spawn.offset!(value)
-    end
+    def offset(value) = spawn.offset!(value)
 
     def offset!(value)
       @offset_value = value
       self
     end
 
-    def reorder(*args)
-      spawn.reorder!(*args)
-    end
+    def reorder(*args) = spawn.reorder!(*args)
 
     def reorder!(*args)
       @order_values = parse_order_args(args)
@@ -81,7 +71,7 @@ module Airrel
       if @order_values.empty?
         raise ArgumentError, "last requires an order to be specified (use .order(:created_at) or similar)"
       end
-      
+
       reversed = reverse_order
       if limit
         # only load what we need
@@ -92,13 +82,9 @@ module Airrel
       end
     end
 
-    def find(id)
-      klass.find(id)
-    end
+    def find(id) = klass.find(id)
 
-    def find_by(conditions)
-      where(conditions).first
-    end
+    def find_by(conditions) = where(conditions).first
 
     def find_by!(conditions)
       # Raise error class that will be defined by the consumer (norairrecord)
@@ -106,19 +92,13 @@ module Airrel
       find_by(conditions) || raise(error_class, "Record not found")
     end
 
-    def all
-      spawn
-    end
+    def all = spawn
 
-    def to_a
-      load_records
-    end
+    def to_a = load_records
 
     alias to_ary to_a
 
-    def each(&block)
-      load_records.each(&block)
-    end
+    def each(&block) = load_records.each(&block)
 
     # batch iteration for large result sets
     def find_each(batch_size: 100, &block)
@@ -127,43 +107,35 @@ module Airrel
       end
     end
 
-    def find_in_batches(batch_size: 100, &block)
+    def find_in_batches(batch_size: 100)
       current_offset = 0
-      
+
       loop do
         # create a new relation with limit and offset
         batch_relation = spawn
         batch_relation.instance_variable_set(:@limit_value, batch_size)
         batch_relation.instance_variable_set(:@offset_value, current_offset)
-        
+
         batch = batch_relation.to_a
         break if batch.empty?
-        
+
         yield batch
-        
+
         break if batch.size < batch_size # last batch
+
         current_offset += batch_size
       end
     end
 
-    def count
-      # airtable doesn't have a count API, but we can optimize by limiting fields
-      # or using exists? check for any?
-      load_records.size
-    end
+    # airtable doesn't have a count API >:-/ we gotta paginate through EVERYTHING...
+    def count = load_records.size
 
-    def empty?
-      !any?
-    end
+    def empty? = !any?
 
-    def any?
-      # optimize: only load 1 record to check existence
-      limit(1).load_records.any?
-    end
-    
-    def exists?
-      any?
-    end
+    # OPTIMIZE: only load 1 record to check existence
+    def any? = limit(1).load_records.any?
+
+    def exists? = any?
 
     # inspection
 
@@ -171,16 +143,12 @@ module Airrel
       entries = load_records.take(11).map!(&:inspect)
       entries[10] = "..." if entries.size == 11
 
-      "#<#{self.class.name} [#{entries.join(', ')}]>"
+      "#<#{self.class.name} [#{entries.join(", ")}]>"
     end
 
-    def to_airtable
-      to_airtable_params
-    end
-    
-    def to_sql
-      to_airtable_params.inspect
-    end
+    def to_airtable = to_airtable_params
+
+    def to_sql = to_airtable_params.inspect
 
     # execution
 
@@ -194,9 +162,7 @@ module Airrel
       load
     end
 
-    def loaded?
-      @loaded
-    end
+    def loaded? = @loaded
 
     def reset
       @loaded = false
@@ -212,9 +178,7 @@ module Airrel
 
     protected
 
-    def spawn
-      clone.tap { |r| r.reset }
-    end
+    def spawn = clone.tap(&:reset)
 
     def load_records
       load unless loaded?
@@ -229,25 +193,23 @@ module Airrel
 
     def to_airtable_params
       params = {}
-      
+
       # filter
-      if @where_clause.any?
-        params[:filter] = @where_clause.to_airtable_formula
-      end
+      params[:filter] = @where_clause.to_airtable_formula if @where_clause.any?
 
       # sort
       if @order_values.any?
-        params[:sort] = @order_values.map { |field, direction|
+        params[:sort] = @order_values.map do |field, direction|
           { field: field.to_s, direction: direction.to_s }
-        }
+        end
       end
 
       # limit
       params[:max_records] = @limit_value if @limit_value
-      
+
       # offset (airtable calls it offset in pagination)
       params[:offset] = @offset_value if @offset_value
-      
+
       # pagination control
       params[:paginate] = @paginate if defined?(@paginate)
 

data/lib/airrel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Airrel
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/lib/airrel/where_clause.rb

@@ -23,19 +23,15 @@ module Airrel
       WhereClause.new(@predicates + new_predicates)
     end
 
-    def any?
-      @predicates.any?
-    end
+    def any? = @predicates.any?
 
     def to_airtable_formula
       return nil if @predicates.empty?
       return @predicates.first if @predicates.size == 1
 
-      "AND(#{@predicates.join(', ')})"
+      "AND(#{@predicates.join(", ")})"
     end
 
-    def inspect
-      @predicates.inspect
-    end
+    def inspect = @predicates.inspect
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: airrel
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - 24c02