record 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bde8b7ec3eaa3f8a683b147cab7b9d25c581ae93
-  data.tar.gz: 5d8a5490efb3b2cce94b1d444736b0bb059aee6d
+  metadata.gz: 905b06c2d1e681e1ae4a2f99b31e1293ab8d455d
+  data.tar.gz: 9a2876f8c7ca014181d75a1e0e02052b17c1546f
 SHA512:
-  metadata.gz: ea21ef1ff6823d00f54f114fefecc8dfce49e541707b5e80af719ba517075d927bfdb69b3ea200c79d660e9cc0e0ff25871bf0dd64d5b635605dbd887b6dd620
-  data.tar.gz: 88bd0b81f611bb908ad749f1bd8873c50c0df5745f96319e3e97cba01d808b23f37324bd067f038a897ff21593c4656c335989cb5bab1cd8ac945d2b5161e479
+  metadata.gz: a6a98f18f4b684db22b4099ccd0bf2a962d7cde44216facd03de97733000ddff62120709ab3766b85fadef58d5e60b88871a278282f9d7a3451cf6432a4edf67
+  data.tar.gz: c48238cbdedd1f50f36aad3ecbc5e9b437af5fd8f356bda68e1d16f5182c5d5af2d1d7866eb0d9a6d04832aff459fec1a133cf2af1a6af746a093aaab30ec485

data/Manifest.txt

@@ -4,4 +4,10 @@ Manifest.txt
 README.md
 Rakefile
 lib/record.rb
+lib/record/base.rb
+lib/record/builder.rb
+lib/record/field.rb
 lib/record/version.rb
+test/helper.rb
+test/test_record.rb
+test/test_version.rb

data/lib/record/base.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+
+module Record
+
+class Base
+
+  def self.fields   ## note: use class instance variable (@fields and NOT @@fields)!!!! (derived classes get its own copy!!!)
+    @fields ||= []
+  end
+
+  def self.field_names   ## rename to header - why? why not?
+    ## return header row, that is, all field names in an array
+    ##   todo: rename to field_names or just names - why? why not?
+    ##  note: names are (always) symbols!!!
+    fields.map {|field| field.name }
+  end
+
+  def self.field_types
+    ##  note: types are (always) classes!!!
+    fields.map {|field| field.type }
+  end
+
+
+
+  def self.field( name, type=:string )
+    num = fields.size  ## auto-calc num(ber) / position index - always gets added at the end
+    field = Field.new( name, num, type )
+    fields << field
+
+    define_field( field )  ## auto-add getter,setter,parse/typecast
+  end
+
+  def self.define_field( field )
+    name = field.name   ## note: always assumes a "cleaned-up" (symbol) name
+    num  = field.num
+
+    define_method( name ) do
+      instance_variable_get( "@values" )[num]
+    end
+
+    define_method( "#{name}=" ) do |value|
+      instance_variable_get( "@values" )[num] = value
+    end
+
+    define_method( "parse_#{name}") do |value|
+      instance_variable_get( "@values" )[num] = field.typecast( value )
+    end
+  end
+
+  ## column/columns aliases for field/fields
+  ##   use self <<  with alias_method  - possible? works? why? why not?
+  def self.column( name, type=:string ) field( name, type ); end
+  def self.columns() fields; end
+  def self.column_names() field_names; end
+  def self.column_types() field_types; end
+
+
+
+
+  def self.build_hash( values )   ## find a better name - build_attrib? or something?
+    ## convert to key-value (attribute) pairs
+    ## puts "== build_hash:"
+    ## pp values
+
+    ## e.g. [[],[]]  return zipped pairs in array as (attribute - name/value pair) hash
+    Hash[ field_names.zip(values) ]
+  end
+
+
+
+  def self.typecast( new_values )
+    values = []
+
+    ##
+    ## todo: check that new_values.size <= fields.size
+    ##
+    ##   fields without values will get auto-filled with nils (or default field values?)
+
+    ##
+    ##  use fields.zip( new_values ).map |field,value| ... instead - why? why not?
+    fields.each_with_index do |field,i|
+       value = new_values[i]   ## note: returns nil if new_values.size < fields.size
+       values << field.typecast( value )
+    end
+    values
+  end
+
+
+  def parse( new_values )   ## use read (from array) or read_values or read_row - why? why not?
+
+    ## todo: check if values overshadowing values attrib is ok (without warning?) - use just new_values (not values)
+    @values = self.class.typecast( new_values )
+    self  ## return self for chaining
+  end
+
+
+  def values
+    ## return array of all record values (typed e.g. float, integer, date, ..., that is,
+    ##   as-is and  NOT auto-converted to string
+    @values
+  end
+
+
+
+  def [](key)
+    if key.is_a? Integer
+      @values[ key ]
+    elsif key.is_a? Symbol
+      ## try attribute access
+      send( key )
+    else  ## assume string
+      ## downcase and symbol-ize
+      ##   remove spaces too -why? why not?
+      ##  todo/fix: add a lookup mapping for (string) titles (Team 1, etc.)
+      send( key.downcase.to_sym )
+    end
+  end
+
+
+
+  def to_h    ## use to_hash - why? why not?  - add attributes alias - why? why not?
+    self.class.build_hash( @values )
+  end
+
+  def initialize( **kwargs )
+    @values = []
+    update( kwargs )
+  end
+
+  def update( **kwargs )
+    pp kwargs
+    kwargs.each do |name,value|
+      ## note: only convert/typecast string values
+      if value.is_a?( String )
+        send( "parse_#{name}", value )  ## note: use parse_<name> setter (for typecasting)
+      else  ## use "regular" plain/classic attribute setter
+        send( "#{name}=", value )
+      end
+    end
+
+    ## todo: check if args.first is an array  (init/update from array)
+    self   ## return self for chaining
+  end
+end ## class Base
+
+
+
+#########
+# alternative class (record) builder
+
+def self.define( super_class=Base, &block )   ## check: rename super_class to base - why? why not?
+  builder = Builder.new( super_class )
+  if block.arity == 1
+    block.call( builder )
+    ## e.g. allows "yield" dsl style e.g.
+    ##  Record.define do |rec|
+    ##     rec.string :team1
+    ##     rec.string :team2
+    ##  end
+    ##
+  else
+    builder.instance_eval( &block )
+    ## e.g. shorter "instance eval" dsl style e.g.
+    ##  Record.define do
+    ##     string :team1
+    ##     string :team2
+    ##  end
+  end
+  builder.to_record
+end
+
+end # module Record

data/lib/record/builder.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+## (record) builder mini language / domain-specific language (dsl)
+
+module Record
+
+class Builder  # check: rename to RecordDefinition or RecordDsl or similar - why? why not?
+  def initialize( super_class=Base )
+    @clazz = Class.new( super_class )
+  end
+
+  def field( name, type=:string )   ## note: type defaults to string
+    puts "  adding field >#{name}< with type >#{type}<"
+    @clazz.field( name, type )  ## auto-add getter and setter
+  end
+
+  def string( name )
+    puts "  adding string field >#{name}<"
+    field( name, :string )
+  end
+
+  def integer( name )  ## use number for alias for integer - why? why not???
+    puts "  adding integer number field >#{name}<"
+    field( name, :integer )
+  end
+
+  def float( name )
+    puts "  adding float number field >#{name}<"
+    field( name, :float )
+  end
+
+
+  def to_record   ## check: rename to just record or obj or finish or end something?
+    @clazz
+  end
+end # class Builder
+end # module Record

data/lib/record/field.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+
+module Record
+
+  ## note on naming:
+  ##   use naming convention from awk and tabular data package/json schema for now
+  ##    use - records  (use rows for "raw" untyped (string) data rows )
+  ##        - fields  (NOT columns or attributes) -- might add an alias later - why? why not?
+
+  class Field  ## ruby record class field
+    attr_reader :name, :type
+
+    ## zero-based position index (0,1,2,3,...)
+    ## todo: use/rename to index/idx/pos - add an alias name - why?
+    attr_reader :num
+
+    def initialize( name, num, type )
+      ## note: always symbol-ify (to_sym) name and type
+
+      ## todo: add title or titles for header field/column title as is e.g. 'Team 1' etc.
+      ##   incl. numbers only or even an empty header title
+      @name = name.to_sym
+      @num  = num
+
+      if type.is_a?( Class )
+        @type = type    ## assign class to its own property - why? why not?
+      else
+        @type = Type.registry[type.to_sym]
+        if @type.nil?
+          puts "!!!! warn unknown type >#{type}< - no class mapping found; add missing type to Record::Type.registry[]"
+          ## todo/fix:  raise exception!!!!
+        end
+      end
+    end
+
+
+    def typecast( value )  ## cast (convert) from string value to type (e.g. float, integer, etc.)
+      ## todo: add typecast to class itself (monkey patch String/Float etc. - why? why not)
+      ##  use __typecast or something?
+      ##  or use a new "wrapper" class  Type::String or StringType - why? why not?
+
+      ## convert string value to (field) type
+      if @type == String
+        value   ## pass through as is
+      elsif @type == Float
+        ## note: allow/check for nil values - why? why not?
+        float = (value.nil? || value.empty?) ? nil : value.to_f
+        puts "typecast >#{value}< to float number >#{float}<"
+        float
+      elsif @type == Integer
+        number = (value.nil? || value.empty?) ? nil : value.to_i(10)   ## always use base10 for now (e.g. 010 => 10 etc.)
+        puts "typecast >#{value}< to integer number >#{number}<"
+        number
+      else
+        ## todo/fix: raise exception about unknow type
+        pp @type
+        puts "!!!! unknown type >#{@type}< - don't know how to convert/typecast string value >#{value}<"
+        value
+      end
+    end
+  end  # class Field
+
+
+
+  class Type   ## todo: use a module - it's just a namespace/module now - why? why not?
+
+    ##  e.g. use Type.registry[:string] = String etc.
+    ##   note use @@ - there is only one registry
+    def self.registry() @@registry ||={} end
+
+    ## add built-in types:
+    registry[:string]  = String
+    registry[:integer] = Integer   ## todo/check: add :number alias for integer? why? why not?
+    registry[:float]   = Float
+    ## todo: add some more
+  end  # class Type
+
+
+end # module Record

data/lib/record/version.rb

@@ -5,7 +5,7 @@ module Record
 
   MAJOR = 1    ## todo: namespace inside version or something - why? why not??
   MINOR = 1
-  PATCH = 0
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
 

data/test/helper.rb

@@ -0,0 +1,9 @@
+## $:.unshift(File.dirname(__FILE__))
+
+## minitest setup
+
+require 'minitest/autorun'
+
+
+## our own code
+require 'record'

data/test/test_record.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_record.rb
+
+
+require 'helper'
+
+class TestRecord < MiniTest::Test
+
+  def test_class_style1
+     clazz1 = Record.define do
+       field :brewery, :string   # fix: do NOT use 'Brewery' - name SHOULD be a valid variable name
+       field :city,    :string
+       field :name     ## default type is :string
+       field :abv,     Float    ## allow type specified as class
+     end
+     pp clazz1
+     pp clazz1.fields
+
+     assert true  ## assume ok if we get here
+  end
+
+  Beer = Record.define do
+     string :brewery   # fix: do NOT use 'Brewery' - name SHOULD be a valid variable name
+     string :city
+     string :name
+     float  :abv
+  end
+
+  class BeerClassic < Record::Base
+    field :brewery
+    field :city
+    field :name
+    field :abv, Float
+  end
+
+
+  def test_class_style2
+    clazz2 = Record.define do
+       string :brewery   # fix: do NOT use 'Brewery' - name SHOULD be a valid variable name
+       string :city
+       string :name
+       float  :abv
+    end
+    pp clazz2
+    pp clazz2.class.name
+    pp clazz2.fields
+
+    clazz2b = Record.define do |rec|   ## try "yield"-style dsl with block.arity == 1
+       rec.string :brewery
+       rec.string :city
+       rec.string :name
+       rec.float  :abv
+    end
+    pp clazz2b
+    pp clazz2b.class.name
+    pp clazz2b.fields
+
+    assert true  ## assume ok if we get here
+  end
+
+
+
+  def test_classic
+    pp BeerClassic.fields
+    pp BeerClassic.field_names
+    pp BeerClassic.columns       ## try fields alias
+    pp BeerClassic.column_names  ## try field_names alias
+
+    assert_equal [:brewery, :city, :name, :abv], BeerClassic.field_names
+    assert_equal [String, String, String, Float], BeerClassic.field_types
+
+    beer = BeerClassic.new
+    pp beer
+    beer.update( abv: 7.0 )
+    beer.update( brewery: 'Andechser Klosterbrauerei',
+                 city:   'Andechs',
+                 name:   'Doppelbock Dunkel' )
+    pp beer
+
+    assert_equal 7.0, beer.abv
+    assert_equal 'Andechser Klosterbrauerei', beer.brewery
+    assert_equal 'Andechs', beer.city
+    assert_equal 'Doppelbock Dunkel', beer.name
+  end
+
+
+  def test_new
+    beer = Beer.new
+    pp beer
+    beer.update( abv: 7.0 )
+    beer.update( brewery: 'Andechser Klosterbrauerei',
+                 city:   'Andechs',
+                 name:   'Doppelbock Dunkel' )
+    pp beer
+
+    assert_equal 7.0, beer.abv
+    assert_equal 'Andechser Klosterbrauerei', beer.brewery
+    assert_equal 'Andechs', beer.city
+    assert_equal 'Doppelbock Dunkel', beer.name
+
+
+    pp beer.abv
+    pp beer.abv = 7.0
+    pp beer.abv
+    assert_equal 7.0, beer.abv
+
+    pp beer.parse_abv( '7%' )   ## (auto-)converts/typecasts string to specified type (e.g. float)
+    assert_equal 7.0, beer.abv
+
+    pp beer.name
+    pp beer.name = 'Doppelbock Dunkel'
+    pp beer.name
+    assert_equal 'Doppelbock Dunkel', beer.name
+
+
+    beer2 = Beer.new( brewery: 'Andechser Klosterbrauerei',
+                      city:   'Andechs',
+                      name:   'Doppelbock Dunkel' )
+    pp beer2
+
+    assert_nil   beer2.abv
+    assert_equal 'Andechser Klosterbrauerei', beer2.brewery
+    assert_equal 'Andechs', beer2.city
+    assert_equal 'Doppelbock Dunkel', beer2.name
+  end
+
+  def test_parse
+    values = ['Andechser Klosterbrauerei',
+              'Andechs',
+              'Doppelbock Dunkel',
+              '7%']
+
+    beer = Beer.new
+    beer.parse( values )
+
+    assert_equal values[0],      beer.brewery
+    assert_equal values[1],      beer.city
+    assert_equal values[2],      beer.name
+    assert_equal values[3].to_f, beer.abv
+
+    assert_equal values[0],      beer[0]
+    assert_equal values[1],      beer[1]
+    assert_equal values[2],      beer[2]
+    assert_equal values[3].to_f, beer[3]
+
+    assert_equal values[0],      beer.values[0]
+    assert_equal values[1],      beer.values[1]
+    assert_equal values[2],      beer.values[2]
+    assert_equal values[3].to_f, beer.values[3]
+
+    assert_equal values[0],      beer[:brewery]
+    assert_equal values[1],      beer[:city]
+    assert_equal values[2],      beer[:name]
+    assert_equal values[3].to_f, beer[:abv]
+
+    assert_equal values[0],      beer['Brewery']
+    assert_equal values[1],      beer['City']
+    assert_equal values[2],      beer['Name']
+    assert_equal values[3].to_f, beer['Abv']
+  end
+
+end # class TestRecord

data/test/test_version.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_version.rb
+
+
+require 'helper'
+
+class TestVersion < MiniTest::Test
+
+  def test_version
+    pp Record::VERSION
+    pp Record.banner
+    pp Record.root
+
+    assert true  ## assume ok if we get here
+  end
+
+end # class TestVersion

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: record
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Gerald Bauer
@@ -54,7 +54,13 @@ files:
 - README.md
 - Rakefile
 - lib/record.rb
+- lib/record/base.rb
+- lib/record/builder.rb
+- lib/record/field.rb
 - lib/record/version.rb
+- test/helper.rb
+- test/test_record.rb
+- test/test_version.rb
 homepage: https://github.com/rubylibs/record
 licenses:
 - Public Domain