ordlite 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6051393488775c98fdee4716e6c49b5cd89c6cd404a45f48024a47dea633acfb
-  data.tar.gz: d43e1d73f1b49b27ae35e745eaa8e13be394635d2367233bc6c341fd1aa54933
+  metadata.gz: 6f1f6f768a785a0badc768db45c1c8ca831958f983b673fe48990846f3d4260e
+  data.tar.gz: 234d31cabdc7ed109144487792da9f77c39821f935e3d7d91a151b91e817d511
 SHA512:
-  metadata.gz: 05e95871ce3a85dd31557e38a4247d5cd38e25406e2ac535a1254e6952e68b8054e8c1a06378b4620ce8168c67d1e4cb7eac50305da9e7e59e2f10152a4aa971
-  data.tar.gz: 3fe7780c583d525dd60170f4ec0e996f430722d53899e3edb321d9af67425024c262a253e1cf718ab0b7316f9fbb3ae0a6903b3a82debf3860511a167872a1ab
+  metadata.gz: 403e1addf0b974af179de293a26c5f1f47da8d0f665da1ca1a44a89cbcfb025a642a04930f49f6df35681527b2cbcaae855f87de4b7ce09e6cd88b4cffab1472
+  data.tar.gz: ab359d39d1dcdf307e8b3239ed61e2f10f8fc6bfc4316c3f9f5554a9fbc2d88b0d1c24f120afcab9b035c675d82d22e0292c6d1202db7219d64f5e8f2c214b54

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 0.2.0 / 2023-07-28
+### 0.2.1
 ### 0.0.1 / 2023-07-01
 
 * Everything is new. First release

data/Manifest.txt

@@ -5,6 +5,7 @@ Rakefile
 lib/ordlite.rb
 lib/ordlite/base.rb
 lib/ordlite/cache.rb
+lib/ordlite/factory.rb
 lib/ordlite/importer.rb
 lib/ordlite/models/blob.rb
 lib/ordlite/models/collection.rb

data/README.md

@@ -13,7 +13,7 @@ ordlite - ordinals inscription (on bitcoin & co) database let's you query via sq
 
 ##  SQL Database Model
 
-Inscribes •  Blobs • Collections • Generatives
+Inscribes • Blobs • Collections • Factories • Generatives
 
 
 Table Inscribes
@@ -63,6 +63,7 @@ puts
 puts "  #{Inscribe.count} inscribe(s)"
 puts "  #{Blob.count} blob(s)"
 puts "  #{Collection.count} collection(s)"
+puts "  #{Factory.count} factories"
 puts "  #{Generative.count} generative(s)"
 
 #=>  0 inscribe(s)
@@ -74,68 +75,134 @@ puts "  #{Generative.count} generative(s)"
 
 
 
-### Example No 1 - Query Ordgen Deploy / Mint Inscriptions
+### Example No 1 - Auto-Add (Via Ordinals.com) First Thousand Inscriptions (Sub 1k)
 
 ``` ruby
 require 'ordlite'
 
 
-OrdDb.connect( adapter:  'sqlite3',
-               database: './ord.db' )
+OrdDb.open( './ord.db' )
 
 
-####################
-## query for deploy candidates
-##
-##  e.g. sql where clause like
-##     content LIKE '%deploy%' 
-##       AND (   content LIKE '%orc-721%' 
-##            OR content LIKE '%og%')
-## 
+1000.times do |num|   # auto-add inscription 0-999
+   OrdDb.import( num )
+end
+
+puts
+puts "  #{Inscribe.count} inscribe(s)"
+puts "  #{Blob.count} blob(s)"
+#=>   1000 inscribe(s)
+#=>   1000 blob(s)
+```
 
-deploys = Inscribe.deploys
-puts "   #{deploys.size} deploy candidate(s)"
+Let's query for the ten biggest (by bytes) inscriptions 
+(and pretty print the result):
 
-deploys.each_with_index do |rec,i|
-    puts "==> deploy #{i} - num #{rec.num} - #{rec.bytes} bytes - #{rec.date}"
-    puts rec.content 
+```ruby
+Inscribe.biggest.limit(10).each do |rec|
+    print "#{number_to_human_size(rec.bytes)} (#{rec.bytes} bytes) - "
+    print "Inscribe №#{rec.num} (#{rec.content_type}) - "
+    print "#{rec.date} - #{rec.fee} fee in sats"
+    print "\n"
 end
+```
 
+resulting in:
 
-punks_deploys = Inscribe.deploys_by( slug: 'diypunks')
-puts "   #{punks_deploys.size} deploy candidate(s)"
+```
+3.73 MB (3915537 bytes) - Inscribe №652 (image/jpeg) - 2023-02-01 20:38:33 - 0 fee in sats
+385 KB (394718 bytes) - Inscribe №978 (application/epub+zip) - 2023-02-02 06:46:04 - 109325 fee in sats
+385 KB (394479 bytes) - Inscribe №546 (image/gif) - 2023-02-01 10:41:50 - 1489860 fee in sats
+385 KB (394440 bytes) - Inscribe №833 (image/png) - 2023-02-02 01:13:51 - 99314 fee in sats
+381 KB (389858 bytes) - Inscribe №388 (image/jpeg) - 2023-01-31 14:01:38 - 981620 fee in sats
+379 KB (388417 bytes) - Inscribe №291 (image/gif) - 2023-01-30 17:58:54 - 586794 fee in sats
+378 KB (386858 bytes) - Inscribe №857 (image/png) - 2023-02-02 01:17:54 - 97407 fee in sats
+374 KB (383322 bytes) - Inscribe №538 (image/jpeg) - 2023-02-01 10:20:28 - 96519 fee in sats
+367 KB (375414 bytes) - Inscribe №378 (image/gif) - 2023-01-31 09:47:55 - 945300 fee in sats
+365 KB (373504 bytes) - Inscribe №288 (image/jpeg) - 2023-01-30 16:51:46 - 94050 fee in sats
+```
 
 
+Let's query for all inscriptions grouped by date (day) and dump the results:
 
-#######################
-## query for mint candidates
-##
-##  e.g. sql where clause like
-##     content LIKE '%mint%' 
-##       AND (   content LIKE '%orc-721%' 
-##            OR content LIKE '%og%')
+```ruby
+pp Inscribe.counts_by_date   ## or count_by_day
+```
 
-mints = Inscribe.mints
-puts "   #{mints.size} mint candidate(s)"
+resulting in:
 
-## print last hundred mint candidates
-mints[-100,100].each_with_index do |rec,i|
-    puts "==> mint #{i} - num #{rec.num} - #{rec.bytes} bytes - #{rec.date}"
-    puts rec.content 
-end
+```
+{"2022-12-14" => 1,
+ "2022-12-17" => 1,
+ "2022-12-19" => 1,
+ "2023-01-05" => 1,
+ "2023-01-10" => 1,
+ "2023-01-12" => 1,
+ "2023-01-13" => 2,
+ "2023-01-15" => 1,
+ "2023-01-16" => 1,
+ "2023-01-19" => 5,
+ "2023-01-20" => 3,
+ "2023-01-21" => 5,
+ "2023-01-22" => 34,
+ "2023-01-23" => 23,
+ "2023-01-24" => 4,
+ "2023-01-25" => 9,
+ "2023-01-26" => 12,
+ "2023-01-27" => 19,
+ "2023-01-28" => 16,
+ "2023-01-29" => 128,
+ "2023-01-30" => 82,
+ "2023-01-31" => 98,
+ "2023-02-01" => 220,
+ "2023-02-02" => 332}
+```
 
+Let's query for all inscriptions grouped by month and dump the results:
+
+```ruby
+pp Inscribe.counts_by_month
+```
+
+resulting in:
+
+```
+{"2022-12" => 3, 
+ "2023-01" => 445, 
+ "2023-02" => 552}
+```
 
-phunks_mints = Inscribe.mints_by( slug: 'diyphunks')
-puts "   #{phunks_mints.size} mint candidate(s)"
 
+Let's query for all content types and group by count (descending) and dump the results:
 
-puts "   #{deploys.size} deploy candidate(s)"
-puts "   #{mints.size} mint candidate(s)"
 
-#=> 123 deploy candidate(s)
-#=> 7453 mint candidate(s)
+```ruby
+pp Inscribe.counts_by_content_type
 ```
 
+resulting in:
+
+```
+{"image/png" => 475,
+ "image/jpeg" => 188,
+ "image/webp" => 117,
+ "text/plain;charset=utf-8" => 112,
+ "image/svg+xml" => 62,
+ "text/html;charset=utf-8" => 18,
+ "image/gif" => 11,
+ "audio/mpeg" => 6,
+ "application/pdf" => 2,
+ "image/avif" => 2,
+ "video/webm" => 2,
+ "application/epub+zip" => 1,
+ "application/pgp-signature" => 1,
+ "audio/midi" => 1,
+ "audio/mod" => 1,
+ "video/mp4" => 1}
+```
+
+and so on.
+
 
 
 
@@ -150,13 +217,10 @@ into an (sql) database e.g. `ord.db`:
 ``` ruby
 require 'ordlite'
 
-OrdDb.connect( adapter:  'sqlite3',
-               database: './ord.db' )
-
-OrdDb.create_all     # build table schema
+OrdDb.open( './ord.db' )
 
 cache_dir = './ordinals.cache/inscription'
-cache =  OrdDb::Cache.new( cache_dir )
+cache = Ordinals::Cache.new( cache_dir )
 cache.import_all
 
 

data/Rakefile

@@ -27,6 +27,7 @@ Hoe.spec 'ordlite' do
     ['props'],
     ['props-activerecord'],
     ['sqlite3'],
+    ['pixelart'],   ## required for factory (ordgen/orc-721) support for now
   ]
 
   self.licenses = ['Public Domain']

data/lib/ordlite/base.rb

@@ -134,5 +134,13 @@ module OrdDb
 end  # module OrdDb
 
 
+
+####
+# add factory (ordgen/orc-721) support here for now - why? why not?
+require 'pixelart'
+require_relative 'factory'
+
+
+
 # say hello
 puts Ordlite.banner     ## if defined?($RUBYCOCOS_DEBUG) && $RUBCOCOS_DEBUG

data/lib/ordlite/factory.rb

@@ -0,0 +1,132 @@
+
+
+class FactorySpritesheet    ## check - rename to catalog or atlas NOT spritesheet - why? why not?
+  def self.read_inscribes( *inscribes, width:, 
+                                       height: )
+     ## map inscribes to images                                  
+     images = inscribes.map {|inscribe| Pixelart::Image.blob( inscribe.content ) }
+     ## puts "  #{images.size} image(s)"
+
+     new( *images, width: width,
+                   height: height)                                
+  end
+
+  def initialize( *images, width:, 
+                           height: )
+     @tile_width  = width
+     @tile_height = height
+     @tiles = []
+     images.each {|img| add(img) }
+  end
+
+  def count() @tiles.size; end
+  alias_method :size,       :count 
+  alias_method :tile_count, :count   ## add tile_count - why? why not?
+  def tile_width() @tile_width; end     ## use width  - why? why not?
+  def tile_height() @tile_height; end   ## use height - why? why not?
+
+  def tile( index )  @tiles[ index ]; end
+  alias_method :[], :tile  
+
+  def add_inscribe( inscribe ) _add( Pixelart::Image.blob( inscribe.content )); end
+  def add( img )
+    ## 1:1 tile; use as is
+    if img.width == @tile_width && img.height == @tile_height
+        @tiles << img 
+    else  ## assume spritesheet??
+      ## wrap into composite image
+      composite = Pixelart::ImageComposite.new( img.image, width:  @tile_width,
+                                                           height: @tile_height )
+      cols  = img.width  / composite.tile_width
+      rows  = img.height / composite.tile_height                                           
+      puts "     #{composite.count} tile(s) in #{cols}x#{rows} grid"
+      composite.each {|tile| @tiles << tile }
+     end
+  end
+  alias_method :<<, :add
+end  ## class Spritesheet
+
+
+class FactoryGenerator
+  ###################
+  ## convenience setup helper(s)
+  def self.read_inscribes( *inscribes, width:, 
+                                       height: )                                         
+        new( FactorySpritesheet.read_inscribes( *inscribes,
+                                                   width: width,
+                                                   height: height ))
+  end
+ 
+  def initialize( spritesheet )
+    @spritesheet = spritesheet
+  end
+ 
+  def _parse( spec )
+    ## for delimiter allow for now:  - why? why not?
+    ##     (multiple) space ( )
+    ##      command or semicolon
+    spec.strip.split( %r{[ ,;/_-]+} ).map {|v| v.to_i(10) }
+  end
+ 
+  def parse( spec )
+    ## convenience helper
+    ##   parses g spec in various (delimited) formats
+    g = _parse( spec )
+    generate( *g )
+  end
+ 
+  def generate( *attributes )
+    img = Pixelart::Image.new( width, height )
+    attributes.each do |num|
+        img.compose!( @spritesheet[ num ] )
+    end
+    img
+  end
+  alias_method :g, :generate
+ 
+  def width()   @spritesheet.tile_width; end
+  def height()  @spritesheet.tile_height; end
+  def count()   @spritesheet.count; end
+end  # class FactoryGenerator
+ 
+
+
+module OrdDb
+module Model
+  
+class Factory
+
+## use id/slug to cache generators / spritesheets - why? why not?
+def self.generators
+    @generators ||= {}
+end
+
+def generator
+    generators = self.class.generators
+    if generators.has_key?( id )
+        generators[ id ]
+    else
+        ## auto-add generator on first-time/hit/demand
+        width, height = _parse_dimension( dim )
+        inscribes = layers.to_a  ## get layer inscribe records
+        generator = FactoryGenerator.read_inscribes( *inscribes,
+                                                     width: width,
+                                                     height: height )
+        generators[ id ] = generator
+        generator                         
+    end
+end
+
+def generate( *attributes )  ## add g shortcut alias - why? why not?
+    generator.generate( *attributes )
+end
+
+
+## e.g. convert dimension (width x height) "24x24" or "24 x 24" to  [24,24]
+def _parse_dimension( str )
+    str.split( /x/i ).map { |str| str.strip.to_i(10) }
+end
+
+end  # class Factory
+end  # module Model
+end  # module OrdDb

data/lib/ordlite/importer.rb

@@ -1,8 +1,82 @@
+module OrdDb
 
+class Importer
+   Inscribe   =  Model::Inscribe
+   Blob       =  Model::Blob
+   Collection =  Model::Collection 
 
-module OrdDb
 
-def self.import_collection( path, content: true )
+
+def import_collection_csv( path,
+                                name:,
+                                content: true )
+## or use
+##  import_collection( format: 'csv') - why? why not?
+   recs = read_csv( path )
+   puts "  #{recs.size} inscribe id(s)"
+
+   col = Collection.find_by( name: name )
+   if col && col.items.count > 0
+     puts "!! WARN - collection already in db; delete first to reimport"
+     return     
+   elsif col
+     ## do nothing; (re)use collection record; add items
+   else
+     col = Collection.create(
+            name:  name
+            ## max:   recs.size   ## auto-add max - why? why not?
+          )
+   end
+
+ recs.each_with_index do |rec,i|
+    id   = rec['id']
+    name = rec['name'] || rec['title']
+    puts "==> #{i+1}/#{recs.size} >#{name}< @ #{id}..."
+
+    col.items.create( pos: i,
+                      inscribe_id: id,
+                      name: name )
+
+    _import( id, content: content )
+ end
+end
+
+
+def import_collection_inscriptions( path, 
+                                         name:, 
+                                         content: true )
+   recs = read_json( path )
+   puts "  #{recs.size} inscribe id(s)"
+
+   col = Collection.find_by( name: name )
+   if col && col.items.count > 0
+     puts "!! WARN - collection already in db; delete first to reimport"
+     return     
+   elsif col
+      ## do nothing; (re)use collection record; add items
+   else
+     col = Model::Collection.create(
+        name:  name  
+        ## max:   recs.size   ## auto-add max - why? why not?
+      )
+   end
+
+   recs.each_with_index do |rec,i|
+      id   = rec['id']
+      meta = rec['meta']
+      name = meta['name']
+      puts "==> #{i+1}/#{recs.size} >#{name}< @ #{id}..."
+ 
+      col.items.create( pos: i,
+                        inscribe_id: id,
+                        name: name )
+
+     _import( id, content: content ) 
+   end
+end
+
+
+def import_collection( path, content: true )
    data = read_json( path )
 
    meta =  data['collection']
@@ -10,13 +84,13 @@ def self.import_collection( path, content: true )
 
    name = meta['name']
 
-   col = Model::Collection.find_by( name: name )
+   col = Collection.find_by( name: name )
    if col
      puts "!! WARN - collection already in db; delete first to reimport"
      return     
    end
    
-   col = Model::Collection.create(
+   col = Collection.create(
       name:  name,
       desc:  meta['description'],
       max:   meta['max_supply']
@@ -33,35 +107,12 @@ def self.import_collection( path, content: true )
                         inscribe_id: id,
                         name: name )
 
-     ## check if inscription / inscribe is already in db?
-     inscribe = Model::Inscribe.find_by( id: id )
-     if inscribe  ## already in db; dump record
-       ## pp inscribe
-     else         ## fetch via ordinals.com api and update db
-        data = Ordinals.inscription( id )
-        pp data
-        Model::Inscribe.create_from_api( data )
-        sleep( 1 )   ## delay in seconds (before next request) 
-     end
-
-     if content
-       ## check if (content) blob is already in db?
-       blob = Model::Blob.find_by( id: id )
-       if blob    ## already in db; do nothing
-       else       ## fetch via ordinals.com api and update db
-          content = Ordinals.content( id )
-          puts "  content-type: #{content.type}"
-          puts "  content-length: #{content.length}"
-       
-          Model::Blob.create( id: id, content: content.data )
-          sleep( 1 )   ## delay in seconds (before next request) 
-       end
-     end              
+     _import( id, content: content )
    end
 end
 
 
-def self.import_csv( path, content: true )
+def import_csv( path, content: true )
     recs = read_csv( path )
     puts "  #{recs.size} inscribe id(s)"
     #=>  1000 inscribe id(s) 
@@ -70,30 +121,98 @@ def self.import_csv( path, content: true )
       id = rec['id']
       puts "==> #{i+1}/#{rec.size} @ #{id}..."
     
-      ## check if inscription / inscribe is already in db?
-      inscribe = Model::Inscribe.find_by( id: id )
-      if inscribe  ## already in db; dump record
-        ## pp inscribe
-      else         ## fetch via ordinals.com api and update db
-         data = Ordinals.inscription( id )
-         pp data
-         Model::Inscribe.create_from_api( data )
-         sleep( 1 )   ## delay in seconds (before next request) 
-      end
+      _import( id, content: content )
+    end  
+end # method import_csv
 
-      if content
-        ## check if (content) blob is already in db?
-        blob = Model::Blob.find_by( id: id )
-        if blob    ## already in db; do nothing
-        else       ## fetch via ordinals.com api and update db
-           content = Ordinals.content( id )
-           puts "  content-type: #{content.type}"
-           puts "  content-length: #{content.length}"
-        
-           Model::Blob.create( id: id, content: content.data )
-           sleep( 1 )   ## delay in seconds (before next request) 
-        end
+def import( id_or_ids, content: true )
+   if id_or_ids.is_a?( String )
+      id = id_or_ids
+     _import( id, content: content )
+   else  ## assume array
+      ids = id_or_ids
+      ids.each do |id|
+         _import( id, content: content )
       end
-    end  
-end # method self.import_csv
+   end
+end 
+
+def _import( id, content: true )
+   ## check if inscription / inscribe is already in db?
+   inscribe = Inscribe.find_by( id: id )
+   if inscribe  ## already in db; dump record
+     ## pp inscribe
+   else         ## fetch via ordinals.com api and update db
+      data = Ordinals.inscription( id )
+
+      pp data
+      Inscribe.create_from_api( data )
+   end
+
+   if content
+     ## check if (content) blob is already in db?
+     blob = Blob.find_by( id: id )
+     if blob    ## already in db; do nothing
+     else       ## fetch via ordinals.com api and update db
+        content = Ordinals.content( id )
+
+        puts "  content-type: #{content.type}"
+        puts "  content-length: #{content.length}"
+     
+        Blob.create( id: id, content: content.data )
+     end
+   end              
+end
+
+end  # class Importer
+
+
+
+###
+## convenience helpers
+
+def self.importer   ## "default" importer
+   @importer ||= Importer.new 
+end
+
+def self.import( id_or_ids, content: true )
+   importer.import( id_or_ids, content: content )
+end
+
+
+def self.import_csv( path, content: true )
+   importer.import_csv( path, content: content )
+end
+
+
+def self.import_collection( path, content: true )
+   importer.import_collection( path, content: content )
+end
+
+def self.import_collection_inscriptions( path, 
+          name:, 
+          content: true )
+   importer.import_collection_inscriptions( path, 
+          name: name, 
+          content: content )
+end
+
+def self.import_collection_csv( path,
+          name:,
+          content: true )
+    importer.import_collection_csv( path,
+           name: name,
+           content: content )
+end
+
+
+module Model 
+class Inscribe
+   def self.import( id_or_ids, content: true )
+       OrdDb.importer.import( id_or_ids, content: content )
+   end
+end  # class Inscribe
+end # module Model 
+
+
 end  # module OrdDb

data/lib/ordlite/models/collection.rb

@@ -2,7 +2,11 @@ module OrdDb
     module Model
   
   class Collection < ActiveRecord::Base    
-    has_many :items, -> { order('pos') }
+    has_many :items   
+    ##  -> { order('pos') }
+    ##   note: default_scope (order)
+    ##      will break all count queries and more
+    ##      thus - no "magic" - always sort if pos order required!!!
     has_many :inscribes, :through => :items                    
   end  # class Collection
   

data/lib/ordlite/models/factory.rb

@@ -7,7 +7,12 @@ module OrdDb
 
     belongs_to :inscribe
     
-    has_many :inscriberefs, -> { order('pos') }  ## join table (use habtm - why? why not?)
+    has_many :inscriberefs  ## join table (use habtm - why? why not?)
+    ##  -> { order('pos') }
+    ##   note: default_scope (order)
+    ##      will break all count queries and more
+    ##      thus - no "magic" - always sort if pos order required!!!
+   
     has_many :layers, :through => :inscriberefs,  
                       :source => :inscribe  
 

data/lib/ordlite/models/inscribe.rb

@@ -66,29 +66,40 @@ SQL
    def self.sub20k()  where( 'num < 20000' ); end
    def self.sub100k()  where( 'num < 100000' ); end
    def self.sub1m()  where( 'num < 1000000' ); end
+   def self.sub2m()  where( 'num < 2000000' ); end
+   def self.sub10m()  where( 'num < 10000000' ); end
+   def self.sub20m()  where( 'num < 20000000' ); end
+   def self.sub21m()  where( 'num < 21000000' ); end
  
 
    def self.largest
       order( 'bytes DESC' )
    end
 
+   def self.address_counts
+       group( 'address' )
+        .order( Arel.sql( 'COUNT(*) DESC')).count
+   end 
+
    def self.block_counts
-      group( 'block' ).count
+       group( 'block' )
+        .order( 'block').count
    end 
    
    def self.block_with_timestamp_counts
-      group( Arel.sql( "block || ' @ ' || date" )).count
+       group( Arel.sql( "block || ' @ ' || date" ))
+        .order( Arel.sql( "block || ' @ ' || date" ) ).count
    end
 
    def self.content_type_counts
-      group( 'content_type' )
+       group( 'content_type' )
        .order( Arel.sql( 'COUNT(*) DESC, content_type')).count
    end
 
 
    def self.date_counts
        ## note: strftime is SQLite specific/only!!!
-       group( Arel.sql("strftime('%Y-%m-%d', date)"))
+      group( Arel.sql("strftime('%Y-%m-%d', date)"))
         .order( Arel.sql("strftime('%Y-%m-%d', date)")).count
    end
 
@@ -100,13 +111,14 @@ SQL
 
    def self.hour_counts
       ## note: strftime is SQLite specific/only!!!
-      group( Arel.sql("strftime('%Y-%m-%d %Hh', date)"))
+       group( Arel.sql("strftime('%Y-%m-%d %Hh', date)"))
        .order( Arel.sql("strftime('%Y-%m-%d %Hh', date)")).count
    end
 
 
    class << self
       alias_method :biggest, :largest
+      alias_method :counts_by_address,      :address_counts
       alias_method :counts_by_content_type, :content_type_counts
       alias_method :counts_by_date,         :date_counts
       alias_method :counts_by_day,          :date_counts

data/lib/ordlite/version.rb

@@ -4,7 +4,7 @@ module Ordlite
   # sync version w/ sport.db n friends - why? why not?
   MAJOR = 0 ## todo: namespace inside version or something - why? why not??
   MINOR = 2
-  PATCH = 0
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ordlite
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-28 00:00:00.000000000 Z
+date: 2023-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ordinals
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pixelart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -173,6 +187,7 @@ files:
 - lib/ordlite.rb
 - lib/ordlite/base.rb
 - lib/ordlite/cache.rb
+- lib/ordlite/factory.rb
 - lib/ordlite/importer.rb
 - lib/ordlite/models/blob.rb
 - lib/ordlite/models/collection.rb