ascii-data-tools 0.9

data/lib/ascii-data-tools/record.rb

@@ -0,0 +1,50 @@
+require 'set'
+
+module AsciiDataTools
+  module Record    
+    class Record
+      attr_reader :type
+      
+      def initialize(type, content_values)
+        @type = type
+        @values_by_type = {:content => content_values}
+      end
+      
+      def [](requested_field_name)
+        requested_key_value_pair = field_names_and_values.detect {|field_name, value| field_name == requested_field_name }
+        raise "Field name '#{requested_field_name}' does not exist!" if requested_key_value_pair.nil?
+        requested_key_value_pair.last
+      end
+      
+      def type_name
+        @type.name
+      end
+      
+      def to_a
+        @type.field_names.zip(values)
+      end
+      
+      def values
+        @values_by_type[:content]
+      end
+      
+      def encode
+        @type.encode(values)
+      end
+      
+      def to_s
+        contents = field_names_and_values.map {|field_name, value| "#{field_name} => #{value.inspect}"}.join(", ")
+        "#{type_name}: #{contents}"
+      end
+      
+      def ==(other)
+        self.type == other.type and self.values == other.values
+      end
+      
+      protected
+      def field_names_and_values
+        @type.field_names.zip(values)
+      end
+    end
+  end
+end

data/lib/ascii-data-tools/record_type.rb

@@ -0,0 +1,139 @@
+require 'set'
+require 'forwardable'
+require 'ascii-data-tools/record_type/field'
+require 'ascii-data-tools/record_type/builder'
+require 'ascii-data-tools/record_type/normaliser'
+require 'ascii-data-tools/record_type/decoder'
+require 'ascii-data-tools/record_type/encoder'
+
+module AsciiDataTools
+  module RecordType
+    module FixedLengthType
+      include Decoder::FixedLengthRecordDecoder
+      include Encoder::FixedLengthRecordEncoder
+      include Normaliser::Normaliser
+      
+      def total_length_of_fields
+        @total_length ||= fields.inject(0) {|sum, field| sum + field.length}
+      end
+    end
+    
+    module CsvType
+      include Decoder::CsvRecordDecoder
+      include Encoder::CsvRecordEncoder
+    end
+    
+    class Type
+      extend Forwardable
+      attr_reader :name
+      
+      def_delegator  :fields, :names, :field_names
+      def_delegator  :fields, :with_index, :field_with_index
+      
+      def initialize(name, content_fields = Field::Fields.new)
+        @name = name
+        @fields_by_type = {:content => content_fields, :meta => make_meta_fields}
+      end
+      
+      def field_with_name(name)
+        all_fields.with_name(name)
+      end
+      
+      def method_missing(method_name, *args, &block)
+        content_fields.send(method_name, *args, &block)
+      end
+      
+      def filename_should_match(value)
+        field_with_name(:filename).should_be_constrained_to(value)
+      end
+      
+      protected
+      attr_reader :fields_by_type
+      
+      def content_fields
+        @fields_by_type[:content]
+      end
+
+      alias :fields :content_fields
+      
+      def make_meta_fields
+        Field::Fields.new([Field::Field.new(:filename), Field::ConstantField.new(:divider)])
+      end
+      
+      def all_fields
+        Field::Fields.new(@fields_by_type[:content] + @fields_by_type[:meta])
+      end
+    end
+    
+    class UnknownType < Type
+      include Decoder::UnknownRecordDecoder
+      UNKNOWN_RECORD_TYPE_NAME = "unknown"
+      
+      def initialize
+        super(UNKNOWN_RECORD_TYPE_NAME, Field::Fields.new([Field::Field.new("UNKNOWN")]))
+      end      
+    end
+
+    class TypeDeterminer
+      def initialize(type_repo = RecordTypeRepository.new)
+        @all_types = type_repo
+        @previously_matched_types = RecordTypeRepository.new
+      end
+
+      def determine_type_for(encoded_record)
+        matching_type = 
+          @previously_matched_types.identify_type_for(encoded_record) || 
+          @all_types.identify_type_for(encoded_record)
+        if matching_type.nil?
+          return UnknownType.new
+        else
+          @previously_matched_types << matching_type
+          return matching_type
+        end
+      end
+    end
+    
+    class RecordTypeRepository
+      include Enumerable
+      include Builder::TypeBuilder
+      
+      def initialize(types = [])
+        @types = Set.new(types)
+      end
+
+      def <<(type)
+        @types << type
+      end
+
+      def clear
+        @types.clear
+      end
+
+      def find_by_name(name)
+        detect {|type| type.name == name}
+      end
+
+      alias :type :find_by_name
+
+      def each(&block)
+        @types.each(&block)
+      end
+
+      def identify_type_for(encoded_record)
+        @types.detect {|type| type.able_to_decode?(encoded_record) }
+      end
+      
+      def for_names_matching(matcher, &block)
+        if matcher.is_a?(Regexp)
+          select {|type| type.name =~ matcher}.each {|found_type| block[found_type]}
+        elsif matcher.is_a?(Proc)
+          select {|type| matcher[type.name]}.each {|found_type| block[found_type]}
+        end
+      end
+      
+      def record_type(name, props = {}, &definition)
+        self << build_type(name, props, &definition)
+      end
+    end
+  end
+end

data/lib/ascii-data-tools/record_type/builder.rb

@@ -0,0 +1,50 @@
+require 'ascii-data-tools/record_type/field'
+
+module AsciiDataTools
+  module RecordType
+    module Builder
+      module FieldBuilder
+        def build_field(name, properties = {})
+          field = Field::FixedLengthField.new(name, properties[:length])
+          field.should_be_constrained_to(properties[:constrained_to]) unless properties[:constrained_to].nil?
+          field.should_be_normalised if properties[:normalised]
+          field
+        end
+      end
+
+      module TypeBuilder
+        include FieldBuilder
+        def build_type(type_name, properties = {}, &block)
+          build_fields(&block)
+          type = Type.new(type_name, @fields)
+          
+          type_family = determine_type_family_from(properties)
+          type.extend(type_family)
+
+          type.field_with_name(:filename).should_be_constrained_to(properties[:applies_for_filenames_matching])
+          type.field_with_name(:divider).value = properties[:divider]
+          type
+        end
+
+        def build_fields(&block)
+          @fields = Field::Fields.new
+          instance_eval(&block) unless block.nil?
+          @fields
+        end
+
+        protected
+        def field(name, properties = {})
+          @fields << build_field(name, properties)
+        end
+        
+        def determine_type_family_from(properties)
+          case properties[:family]
+          when "csv" then CsvType
+          when "fixed_length" then FixedLengthType
+          when NilClass then FixedLengthType
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ascii-data-tools/record_type/decoder.rb

@@ -0,0 +1,77 @@
+module AsciiDataTools
+  module RecordType
+    module Decoder
+      module RecordDecoder
+        def able_to_decode?(encoded_record)
+          able_to_decode_content?(encoded_record[:ascii_string]) and meta_fields_valid?(encoded_record)
+        end
+
+        def decode(encoded_record)
+          Record::Record.new(self, split_into_values(encoded_record[:ascii_string]))
+        end
+        
+        protected
+        def able_to_decode_content?(encoded_string)
+          raise "Must be implemented in submodule!"
+        end
+        
+        def split_into_values(ascii_string)
+          raise "Must be implemented in submodule!"
+        end
+        
+        def meta_fields_valid?(encoded_record)
+          encoded_record[:filename].nil? or filename_field.valid_input?(encoded_record[:filename])
+        end
+        
+        def filename_field
+          @filename_field ||= fields_by_type[:meta].with_name(:filename)
+        end
+      end
+      
+      module RegexpBasedDecoder
+        include RecordDecoder
+
+        protected
+        def able_to_decode_content?(encoded_string)
+          encoded_string =~ regexp_for_matching_type
+        end
+        
+        def split_into_values(ascii_string)
+          ascii_string.match(regexp_for_matching_type).to_a[1..-1]
+        end
+        
+        def regexp_for_matching_type
+          @regexp ||= Regexp.new(regexp_string, Regexp::MULTILINE)
+        end
+        
+        def regexp_string
+          raise "Must be implemented in submodule!"
+        end
+      end
+      
+      module FixedLengthRecordDecoder
+        include RegexpBasedDecoder
+        
+        protected        
+        def regexp_string
+          content_fields.inject("\\A") {|regexp_string, field| field.extend_regexp_string_for_matching(regexp_string) } + "\\z"
+        end
+      end
+      
+      module CsvRecordDecoder
+        include RegexpBasedDecoder
+        
+        protected
+        def regexp_string
+          "\\A" + "(.*?)" + ((field_with_name(:divider).value + "(.*?)") * (content_fields.length - 1))  + "\n\\z"
+        end
+      end
+      
+      module UnknownRecordDecoder
+        def decode(encoded_record)
+          Record::Record.new(self, [encoded_record[:ascii_string]])
+        end
+      end
+    end
+  end
+end

data/lib/ascii-data-tools/record_type/encoder.rb

@@ -0,0 +1,17 @@
+module AsciiDataTools
+  module RecordType
+    module Encoder
+      module FixedLengthRecordEncoder
+        def encode(values)
+          values.join
+        end
+      end
+      
+      module CsvRecordEncoder
+        def encode(values)
+          values.join(field_with_name(:divider).value) + "\n"
+        end
+      end
+    end
+  end
+end

data/lib/ascii-data-tools/record_type/field.rb

@@ -0,0 +1,168 @@
+module AsciiDataTools
+  module RecordType
+    module Field
+      module GreppableFields
+        def with_name(field_name)
+          self.detect {|field| field.name == field_name}
+        end
+        
+        def fields_with(&block)
+          Fields.new(self.select(&block))
+        end
+        
+        def with_index(index)
+          self[index-1]
+        end
+      end
+      
+      class Fields < Array
+        include GreppableFields
+        def names
+          self.collect {|f| f.name}
+        end
+        
+        def number_of_content_fields
+          self.size
+        end
+        
+        def length_of_longest_field_name
+          @length_of_longest_field_name ||= names.max_by {|name| name.length }.length
+        end
+        
+        def constraints_description
+          self.reject {|field| field.constraint_description.empty? }.map {|field| field.constraint_description}.join(", ")
+        end
+        
+        def should_be_normalised
+          self.each {|field| field.should_be_normalised}
+        end
+        
+        def names_of_normalised_fields
+          self.select {|field| field.normalised?}.map {|field| field.name}.join(", ")
+        end
+      end
+      
+      class Field
+        attr_reader :name
+        attr_writer :constraint
+      
+        def initialize(name, constraint = NoConstraint.new)
+          @name = name
+          @constraint = constraint
+          @normalised = false
+        end
+      
+        def normalised?
+          @normalised
+        end
+      
+        def should_be_normalised
+          @normalised = true
+        end
+      
+        def constraint_description
+          unless @constraint.to_s.empty?
+            name.to_s + " " + @constraint.to_s
+          else
+            ""
+          end
+        end
+
+        def should_be_constrained_to(value)
+          if value.is_a?(Regexp)
+            @constraint = RegexpConstraint.new(value)
+          else
+            @constraint = OneOfConstraint.new(value)
+          end
+        end
+        
+        def valid_input?(value)
+          @constraint.satisfied_by?(value)
+        end
+      end
+      
+      class ConstantField < Field
+        attr_accessor :value
+      end
+      
+      class FixedLengthField < Field
+        attr_reader :length
+      
+        def initialize(name, length, constraint = nil)
+          super(name, constraint || FixedLengthConstraint.new(length))
+          @length = length
+        end
+      
+        def extend_regexp_string_for_matching(regexp_string)
+          @constraint.extend_regexp_string_for_matching(regexp_string)
+        end
+      end
+    
+      class NoConstraint
+        def extend_regexp_string_for_matching(regexp_string)
+          regexp_string
+        end
+      
+        def satisfied_by?(string)
+          true
+        end
+      
+        def to_s; ""; end
+      end
+    
+      class Constraint
+        def satisfied_by?(string)
+          string =~ Regexp.new(extend_regexp_string_for_matching(""))
+        end
+      end
+    
+      class FixedLengthConstraint < Constraint
+        def initialize(length)
+          @length = length
+        end
+      
+        def extend_regexp_string_for_matching(regexp_string)
+          regexp_string + "(.{#{@length}})"
+        end
+      
+        def to_s; ""; end
+      end
+    
+      class OneOfConstraint < Constraint
+        def initialize(*possible_values)
+          @possible_values = possible_values.flatten
+        end
+      
+        def extend_regexp_string_for_matching(regexp_string)
+          regexp_string + "(#{@possible_values.join('|')})"
+        end
+      
+        def to_s
+          if @possible_values.length == 1
+            "= #{@possible_values.first}"
+          else
+            "one of #{@possible_values.join(', ')}"
+          end
+        end
+      end
+    
+      class RegexpConstraint < Constraint
+        def initialize(regexp_that_must_match)
+          @regexp_that_must_match = regexp_that_must_match
+        end
+
+        def extend_regexp_string_for_matching(regexp_string)
+          regexp_string + @regexp_that_must_match.source
+        end
+
+        def satisfied_by?(string)
+          string =~ @regexp_that_must_match
+        end
+
+        def to_s
+          "=~ #{@regexp_that_must_match.inspect}"
+        end
+      end
+    end
+  end
+end