conformist 0.0.3 → 0.1.0

data/lib/conformist/builder.rb

@@ -0,0 +1,10 @@
+module Conformist
+  class Builder
+    def self.call schema, enumerable
+      columns = schema.columns
+      columns.inject HashStruct.new do |hash, column|
+        hash.merge column.name => column.values_in(enumerable)
+      end
+    end
+  end
+end

data/lib/conformist/column.rb

@@ -1,26 +1,23 @@
 module Conformist
   class Column
-    attr_reader :name, :indexes, :preprocessor
+    attr_accessor :name, :indexes, :preprocessor
         
     def initialize name, *indexes, &preprocessor
-      @name, @indexes, @preprocessor = name, indexes, preprocessor
+      self.name         = name
+      self.indexes      = indexes
+      self.preprocessor = preprocessor
     end
     
-    # Map column(s) into a single value, strips whitespace and performs
-    # any preprocessing. Takes a +row+ argument that should behave as an
-    # array-like object.
-    #
-    # Example:
-    #
-    #   row    = ['Hello', 'World']
-    #   column = Column.new :first, 0
-    #   column.value_in row # => 'Hello'
-    #
-    # Returns preprocessed value.
-    def values_in row      
-      values = indexes.map { |index| row[index] ? row[index].strip : nil }
-      values = values.first if values.size == 1
-      if preprocessor.respond_to? :call
+    def values_in array
+      values = array.values_at(*indexes).map do |value|
+        if value.respond_to? :strip
+          value.strip
+        else
+          value
+        end
+      end    
+      values = values.first if values.size == 1  
+      if preprocessor
         preprocessor.call values
       else
         values

data/lib/conformist/hash_struct.rb

@@ -0,0 +1,33 @@
+module Conformist
+  class HashStruct
+    extend Forwardable
+    
+    attr_accessor :attributes
+        
+    def_delegators :attributes, :[], :[]=, :fetch, :key?
+    
+    def initialize attributes = {}
+      self.attributes = attributes
+    end
+    
+    def merge other
+      self.class.new.tap do |instance|
+        instance.attributes = attributes.merge other
+      end
+    end
+    
+    def == other
+      other.class == self.class && attributes == other.attributes
+    end
+    
+  protected
+  
+    def respond_to_missing? method, include_private
+      key?(method) || super
+    end
+    
+    def method_missing method, *args, &block
+      fetch(method) { super }
+    end
+  end
+end

data/lib/conformist/schema.rb

@@ -0,0 +1,66 @@
+module Conformist  
+  module Schema
+    def self.included base
+      base.send :include, InstanceExtensions
+      base.send :include, Methods
+    end
+    
+    def self.extended base
+      base.extend ClassExtensions
+      base.extend Methods
+    end
+    
+    module ClassExtensions
+      def inherited base
+        base.builder = builder.dup
+        base.columns = columns.dup
+      end
+      
+      def load *args
+        raise "``#{self.class}.load` has been removed, use something like `#{self.class}.conform(file).each(&block)` instead (#{caller.first})"
+      end
+    end
+    
+    module InstanceExtensions
+      def initialize super_schema = nil, &block
+        if super_schema
+          self.builder = super_schema.builder.dup
+          self.columns = super_schema.columns.dup
+        end
+        if block
+          instance_eval &block 
+        end
+      end
+    end
+    
+    module Methods
+      def builder
+        @builder ||= Builder
+      end
+
+      def builder= value
+        @builder = value
+      end
+
+      def column *args, &block
+        columns << Column.new(*args, &block)
+      end
+
+      def columns
+        @columns ||= []
+      end
+
+      def columns= value
+        @columns = value
+      end
+
+      def conform enumerables
+        Enumerator.new do |yielder|
+          enumerables.each do |enumerable|
+            yielder.yield builder.call(self, enumerable)
+          end
+        end
+      end      
+    end
+  end
+end

data/lib/conformist/version.rb

@@ -1,3 +1,3 @@
 module Conformist
-  VERSION = '0.0.3'
+  VERSION = '0.1.0'
 end

data/test/helper.rb

@@ -1,13 +1,4 @@
-require 'minitest/autorun'
-
 require 'conformist'
-require 'definitions/acma'
-require 'definitions/fcc'
-
-def stub_row
-  ('a'..'d').to_a
-end
+require 'minitest/autorun'
 
-def fixture file
-  File.expand_path "../fixtures/#{file}", __FILE__
-end
+include Conformist

data/test/schemas/acma.rb

@@ -0,0 +1,15 @@
+class ACMA
+  extend Conformist
+
+  column :name, 11 do |value| 
+    value.match(/[A-Z]+$/)[0].upcase
+  end
+  column :callsign, 1
+  column :latitude, 15
+end
+
+class ACMA::Digital < ACMA
+  column :signal_type do 
+     'digital'
+   end
+end

data/test/{definitions → schemas}/fcc.rb

@@ -1,8 +1,6 @@
 class FCC
-  include Conformist::Base
-  
-  option :col_sep => '|'
-   
+  extend Conformist
+     
   column :name, 10, 11 do |values|
     "#{values[0].upcase}, #{values[-1]}"
   end

data/test/unit/conformist/base_test.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class BuilderTest < MiniTest::Unit::TestCase
+  def test_included
+    assert_raises RuntimeError do
+      Class.new { include Base }
+    end
+  end
+end

data/test/unit/conformist/builder_test.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class BuilderTest < MiniTest::Unit::TestCase
+  def test_call
+    column = MiniTest::Mock.new
+    column.expect :name, :a
+    column.expect :values_in, [1], [Array]
+    definition = MiniTest::Mock.new
+    definition.expect :columns, [column]
+    assert_equal HashStruct.new({:a => [1]}), Builder.call(definition, [])
+  end
+end

data/test/{conformist → unit/conformist}/column_test.rb

@@ -1,6 +1,10 @@
 require 'helper'
 
 class ColumnTest < MiniTest::Unit::TestCase
+  def stub_row
+    ('a'..'d').to_a
+  end
+  
   def test_name
     column = Conformist::Column.new :foo
     assert_equal :foo, column.name

data/test/unit/conformist/hash_struct_test.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+class HashStructTest < MiniTest::Unit::TestCase
+  def test_initialize
+    assert_equal({:a => 1}, HashStruct.new({:a => 1}).attributes)
+    assert_empty HashStruct.new.attributes
+  end
+  
+  def test_delegates
+    hash = HashStruct.new
+    assert hash.respond_to?(:[])
+    assert hash.respond_to?(:[]=)
+    assert hash.respond_to?(:fetch)
+    assert hash.respond_to?(:key?)
+  end
+  
+  def test_equality
+    hash1 = HashStruct.new :a => 1
+    hash2 = HashStruct.new :a => 1
+    hash3 = MiniTest::Mock.new
+    hash3.expect :attributes, {:a => 1}
+    hash3.expect :class, MiniTest::Mock
+    assert_equal hash1, hash2
+    refute_equal hash1, hash3
+  end
+  
+  def test_merge
+    hash1 = HashStruct.new
+    hash2 = hash1.merge :a => 1
+    refute_equal hash1.object_id, hash2.object_id
+    refute_equal 1, hash1[:a]
+    assert_equal 1, hash2[:a]
+  end
+  
+  def test_readers_with_method_missing
+    hash = HashStruct.new :a => 1, :c_d => 1
+    assert_equal 1, hash.a
+    assert_equal 1, hash.c_d
+  end
+  
+  if respond_to? :respond_to_missing? # Compatible with 1.9
+    def test_readers_with_respond_to_missing
+      hash = HashStruct.new :a => 1, :c_d => 1
+      assert hash.respond_to?(:a)
+      assert hash.respond_to?(:c_d)
+    end
+  end
+end

data/test/unit/conformist/schema_test.rb

@@ -0,0 +1,74 @@
+require 'helper'
+
+class SchemaTest < MiniTest::Unit::TestCase
+  def test_initialize_with_instance
+    parent = Class.new { include Schema }.new.tap { |d| d.columns = [0] }
+    child1 = Class.new { include Schema }.new(parent).tap { |d| d.columns << 1 }
+    child2 = Class.new { include Schema }.new(parent).tap { |d| d.columns << 2 }
+    assert_equal [0], parent.columns
+    assert_equal [0, 1], child1.columns
+    assert_equal [0, 2], child2.columns
+  end
+
+  def test_initialize_with_block
+    anonymous = Class.new { include Schema }.new do
+      column :a, 0
+      column :b, 1
+    end
+    assert_equal 2, anonymous.columns.size
+  end
+  
+  def test_builder_reader
+    assert_equal Builder, Class.new { extend Schema }.builder
+  end
+
+  def test_builder_writer
+    definition = Class.new { extend Schema }
+    definition.builder = Object
+    assert_equal Object, definition.builder
+  end  
+
+  def test_columns_reader
+    assert_empty Class.new { extend Schema }.columns
+  end
+
+  def test_columns_writer
+    definition = Class.new { extend Schema }
+    definition.columns = [1]
+    assert_equal [1], definition.columns
+  end
+
+  def test_column
+    definition = Class.new { extend Schema }
+    definition.column :a, 0
+    definition.column :b, 1
+    assert_equal 2, definition.columns.size
+  end
+
+  def test_conform_returns_enumerable
+    definition = Class.new { extend Schema }
+    assert definition.conform([]).respond_to?(:each)
+    assert definition.conform([]).respond_to?(:map)
+  end
+
+  def test_conform_calls_builders_call_method
+    definition = Class.new { extend Schema }
+    definition.builder = lambda { |definition, value| value }
+    assert_equal [2, 4], definition.conform([1, 2]).map { |value| value * 2 }
+  end
+
+  def test_inheritance
+    parent = Class.new { extend Schema }.tap { |d| d.columns = [0] }
+    child1 = Class.new(parent).tap { |d| d.columns << 1 }
+    child2 = Class.new(parent).tap { |d| d.columns << 2 }
+    assert_equal [0], parent.columns
+    assert_equal [0, 1], child1.columns
+    assert_equal [0, 2], child2.columns
+  end
+  
+  def test_load
+    assert_raises RuntimeError do
+      Class.new { extend Schema }.load
+    end
+  end
+end

data/test/unit/conformist_test.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+class ConformistTest < MiniTest::Unit::TestCase
+  def test_extended
+    definition = Class.new { extend Conformist }
+    assert definition.respond_to?(:builder)
+    assert definition.respond_to?(:columns)
+    assert definition.respond_to?(:conform)
+  end
+  
+  def test_foreach
+    assert_raises RuntimeError do
+      Conformist.foreach
+    end
+  end
+  
+  def test_new
+    assert Conformist.new.class.include?(Schema)
+  end
+end

data/test/unit/integration_test.rb

@@ -0,0 +1,72 @@
+require 'csv'
+require 'helper'
+require 'schemas/acma'
+require 'schemas/fcc'
+
+class IntegrationTest < MiniTest::Unit::TestCase
+  def open_csv filename, options = {}
+    path = File.expand_path "../../fixtures/#{filename}", __FILE__
+    if CSV.method(:open).arity == -3 # 1.8 CSV
+      CSV.open path, 'r', options[:col_sep]
+    else
+      CSV.open path, options
+    end
+  end
+
+  def test_class_with_csv
+    enumerable = ACMA.conform open_csv('acma.csv')
+    last       = enumerable.to_a.last
+    assert_equal HashStruct.new(:name=>'CRAFERS', :callsign=>'ADS10', :latitude=>'34 58 57S'), last
+  end
+  
+  def test_inherited_class_with_csv
+    enumerable = ACMA::Digital.conform open_csv('acma.csv')
+    last       = enumerable.to_a.last
+    assert_equal HashStruct.new(:name=>'CRAFERS', :callsign=>'ADS10', :latitude=>'34 58 57S', :signal_type => 'digital'), last
+  end
+  
+  def test_class_with_psv
+    enumerable = FCC.conform open_csv('fcc.txt', :col_sep => '|')
+    last       = enumerable.to_a.last
+    assert_equal HashStruct.new(:name => 'LOS ANGELES, CA', :callsign => 'KVTU-LP', :latitude => '34 13 38.00 N', :signtal_type => 'digital'), last
+  end
+  
+  def test_instance_with_array_of_arrays
+    data = Array.new.tap do |d|
+      d << ['NSW', 'New South Wales', 'Sydney']
+      d << ['VIC', 'Victoria', 'Melbourne']
+      d << ['QLD', 'Queensland', 'Brisbane']
+    end
+    definition = Conformist.new do
+      column :state, 0, 1 do |values|
+        "#{values.first}, #{values.last}"
+      end
+      column :capital, 2
+    end
+    enumerable = definition.conform data
+    last = enumerable.to_a.last
+    assert_equal HashStruct.new(:state => 'QLD, Queensland', :capital => 'Brisbane'), last
+  end
+  
+  def test_inherited_instance_with_array_of_arrays
+    data = Array.new.tap do |d|
+      d << ['NSW', 'New South Wales', 'Sydney']
+      d << ['VIC', 'Victoria', 'Melbourne']
+      d << ['QLD', 'Queensland', 'Brisbane']
+    end
+    parent = Conformist.new do
+      column :state, 0, 1 do |values|
+        "#{values.first}, #{values.last}"
+      end
+      column :capital, 2
+    end
+    child = Conformist.new parent do
+      column :country do 
+        'Australia'
+      end
+    end
+    enumerable = child.conform data
+    last = enumerable.to_a.last
+    assert_equal HashStruct.new(:state => 'QLD, Queensland', :capital => 'Brisbane', :country => 'Australia'), last
+  end
+end