table-query 0.1.0

data/example/simple/simple-query.rb

@@ -0,0 +1,6 @@
+require 'table-query'
+
+path = File.join(File.dirname(__FILE__), "simple.csv")
+table = TableQuery.table(path)
+p table.number_to_char(1).entries  # => [:a, :b, :c]
+p table.char_to_number(:b).entries # => [1, 3]

data/example/simple/simple-schema.rb

@@ -0,0 +1,17 @@
+# data fields schema
+table.define do
+  field :number, :int
+  field :char, :symbol
+end
+
+# query schema bthat named "number_to_char"
+query.define(:number_to_char) do
+  input :number
+  output :char
+end
+
+# query schema that named "char_to_number"
+query.define(:char_to_number) do
+  input :char
+  output :number
+end

data/example/simple/simple.csv

@@ -0,0 +1,6 @@
+1,a
+1,b
+1,c
+2,a
+2,c
+3,b

data/lib/table-query.rb

@@ -0,0 +1,26 @@
+require 'csv'
+require 'date'
+
+require 'table-query/field'
+require 'table-query/query'
+require 'table-query/type'
+require 'table-query/table-schema'
+require 'table-query/query-schema'
+require 'table-query/schema-loader'
+require 'table-query/table'
+
+# TableQuery provides table definition schema and the query.
+# You can get table data by easy way.
+module TableQuery
+  # Create a table.
+  #
+  # @param path [String]
+  #   table data file path
+  # @param options [Hash]
+  #   table options
+  # @return [Table]
+  #   table
+  def self.table(path, options={})
+    Table.new(path, options)
+  end
+end

data/lib/table-query/field.rb

@@ -0,0 +1,4 @@
+module TableQuery
+  # Field represents table fields.
+  Field = Struct.new(:name, :type, :pos, :value, :options)
+end

data/lib/table-query/query-schema.rb

@@ -0,0 +1,96 @@
+module TableQuery
+  # QuerySchema defines query's input and output field relation.
+  class QuerySchema
+    # Define a new query schema.
+    #
+    # @param name [Symbol]
+    #   query name
+    # @return [QuerySchema]
+    #   new query schema
+    def self.define(name, &b)
+      new(name).tap {|x| x.instance_eval(&b)}
+    end
+
+    # query name
+    # @return [Symbol]
+    attr_reader :name
+
+    # input field list
+    # @return [Array<Field>]
+    attr_reader :inputs
+
+    # output field list
+    # @return [Array<Field>]
+    attr_reader :outputs
+
+    # preset value list
+    # @return [Array<Field>]
+    attr_reader :values
+
+    # Create a query schema object.
+    #
+    # @param name [Symbol]
+    #   query name
+    def initialize(name)
+      @name = name
+      @inputs = []
+      @outputs = []
+      @values = []
+      @table = nil
+    end
+
+    # Define an input field.
+    #
+    # @param name [Symbol]
+    #   field name
+    # @param options [Hash]
+    #   input options
+    # @return [void]
+    def input(name, options={})
+      @inputs << Field.new(name, nil, nil, nil, options)
+    end
+
+    # Define an output field.
+    #
+    # @param name [Symbol]
+    #   field name
+    # @param options [Hash]
+    #   output options
+    # @return [void]
+    def output(name, options={})
+      @outputs << Field.new(name, nil, nil, nil, options)
+    end
+
+    # Define pre set value of the query.
+    #
+    # @param name [Symbol]
+    #   field name
+    # @param val [Object]
+    #   table data
+    # @param options [Hash]
+    #   value options
+    # @return [void]
+    def value(name, val, options={})
+      @values << Field.new(name, nil, nil, val, options)
+    end
+
+    # Set target table for query.
+    #
+    # @param table [Table]
+    #   query target table
+    # @return [void]
+    # @api private
+    def set_table(table)
+      @table = table
+      @table.table_schema.fields.each do |field|
+        (@inputs + @outputs + @values).each do |item|
+          if field.name == item.name
+            item.pos = field.pos
+            item.type = @table.types[field.type]
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/table-query/query.rb

@@ -0,0 +1,54 @@
+module TableQuery
+  # Query is a class for providing query interfaces. This is enumerable, so you
+  # can access results by various enumeration methods.
+  class Query
+    include Enumerable
+
+    # target table
+    # @return [Table]
+    attr_reader :table
+
+    # query schema
+    # @return [QuerySchema]
+    attr_reader :query_schema
+
+    # query values
+    # @return [Array<Object>]
+    attr_reader :values
+
+    # Create a query interface.
+    def initialize(table, query_schema, vals)
+      @table = table
+      @query_schema = query_schema
+      @values = vals
+    end
+
+    # This is an enumeration method. If block is not given, then return an
+    # +Enumerator+ object.
+    def each
+      if block_given?
+        vals = []
+        @query_schema.inputs.each_with_index do |input, i|
+          vals << input.type.convert_from_ruby(@values[i])
+        end
+        @table.csv.each do |row|
+          if @query_schema.inputs.zip(vals).all? {|input, val| row[input.pos] == val} and
+              @query_schema.values.all? {|value| row[value.pos] == value.type.convert_from_ruby(value.value)}
+            outputs = []
+            cond = @query_schema.outputs.each do |output|
+              val = row[output.pos]
+              if output.options[:empty] == :ignore and val == ""
+                break :break
+              else
+                outputs << output.type.convert_to_ruby(val)
+              end
+            end
+            yield *outputs unless cond == :break
+          end
+        end
+      else
+        return Enumerator.new(self)
+      end
+    end
+  end
+end

data/lib/table-query/schema-loader.rb

@@ -0,0 +1,92 @@
+module TableQuery
+  # SchemaLoader provides functions to load schema file and evaluation context.
+  class SchemaLoader
+    # VariableType is a class for +type+ special variable.
+    # @api private
+    class VariableType
+      attr_reader :value
+
+      def initialize
+        @value = {}
+      end
+
+      def define(name, &b)
+        @value[name] = Type.define(name, &b)
+      end
+    end
+
+    # VariableTable is a class for +table+ special variable.
+    # @api private
+    class VariableTable
+      attr_reader :value
+
+      def define(&b)
+        @value = TableSchema.define(&b)
+      end
+    end
+
+    # VariableQuery is a class for +query+ special variable.
+    # @api private
+    class VariableQuery
+      attr_reader :value
+
+      def initialize
+        @value = {}
+      end
+
+      def define(name, &b)
+        @value[name] = QuerySchema.define(name, &b)
+      end
+    end
+
+    # Evaluation context for schema definition.
+    class Context
+      attr_reader :type
+      attr_reader :table
+      attr_reader :query
+
+      # Create a context.
+      def initialize
+        @type = VariableType.new
+        @table = VariableTable.new
+        @query = VariableQuery.new
+      end
+
+      # Return the context binding.
+      def binding
+        Kernel.binding
+      end
+    end
+
+    # Load schema file and evaluate.
+    #
+    # @param src [String]
+    #   schema source
+    # @param filename [String]
+    #   filename
+    def self.load(src, filename)
+      new(src, filename).eval
+    end
+
+    # Create a new loader.
+    #
+    # @param src [String]
+    #   schema source
+    # @param filename [String]
+    #   filename
+    def initialize(src, filename)
+      @src = src
+      @filename = filename
+      @context = Context.new
+    end
+
+    # Evaluate schema file.
+    #
+    # @return [Array<Array<Type>, TableSchema, Array<QuerySchema>>]
+    #   schema contents
+    def eval
+      @context.binding.eval(@src, @filename)
+      [@context.type.value, @context.table.value, @context.query.value]
+    end
+  end
+end

data/lib/table-query/table-schema.rb

@@ -0,0 +1,34 @@
+module TableQuery
+  # TableSchema defines table fields.
+  class TableSchema
+    # Define a new table schema.
+    #
+    # @param b [Proc]
+    #   schema definition
+    # @return [TableSchema]
+    #   table schema
+    def self.define(&b)
+      new.tap {|x| x.instance_eval(&b)}
+    end
+
+    # table field list
+    # @return [Array<Field>]
+    attr_reader :fields
+
+    # Create a new table schema.
+    def initialize
+      @fields = []
+    end
+
+    # Add a table field.
+    #
+    # @param name [Symbol]
+    #   field name
+    # @param type [Symbol]
+    #   field type name
+    # @return [void]
+    def field(name, type)
+      @fields << Field.new(name, type, @fields.size, nil, {})
+    end
+  end
+end

data/lib/table-query/table.rb

@@ -0,0 +1,61 @@
+module TableQuery
+  # Table is a class for loading table data/schema files and providing
+  # interfaces for query.
+  class Table
+    # table field type list
+    attr_reader :types
+
+    # table schema
+    attr_reader :table_schema
+
+    # table query schema list
+    attr_reader :query_schemas
+
+    # @api private
+    attr_reader :csv
+
+    # Create a new table.
+    #
+    # @param path [String]
+    #   table data file path
+    # @param options [Hash]
+    #   table options
+    def initialize(path, options={})
+      @path = path
+      @csv = CSV.read(path)
+
+      eval_schema_file
+      setup_query_schemas
+    end
+
+    # Return schema filename.
+    #
+    # @return [String]
+    #   schema filename
+    def schema_path
+      name = "%s-schema.rb" % File.basename(@path, ".*")
+      File.join(File.dirname(@path), name)
+    end
+
+    private
+
+    # Evaluate schema file.
+    def eval_schema_file
+      src = File.read(schema_path)
+      types, @table_schema, @query_schemas = SchemaLoader.load(src, schema_path)
+      standard_types = Hash[STANDARD_TYPES.map{|type| [type.name, type]}]
+      @types = standard_types.merge(types)
+    end
+
+    # Setup query schemas to access the table.
+    def setup_query_schemas
+      @query_schemas.each do |name, schema|
+        schema.set_table self
+        singleton = class << self; self; end
+        singleton.send(:define_method, name) do |*vals|
+          Query.new(self, schema, vals)
+        end
+      end
+    end
+  end
+end

data/lib/table-query/type.rb

@@ -0,0 +1,121 @@
+module TableQuery
+  # Type is a class for data conversion.
+  class Type
+    # Define new type with the block.
+    #
+    # @return [Type]
+    #   type object
+    def self.define(name, &b)
+      new(name).tap {|x| x.instance_eval(&b)}
+    end
+
+    # Return the type name.
+    attr_reader :name
+
+    # Create new type.
+    #
+    # @param name [Symbol]
+    #   type name
+    def initialize(name)
+      @name = name
+    end
+
+    # Define a converter data to ruby object.
+    #
+    # @param b [Proc]
+    #   table data to ruby object converter
+    # @return [void]
+    def to_ruby(&b)
+      @to_ruby = b
+    end
+
+    # Define a converter ruby object to data.
+    #
+    # @param b [Proc]
+    #   ruby object to table data converter
+    # @return [void]
+    def from_ruby(&b)
+      @from_ruby = b
+    end
+
+    # Convert the data to ruby object.
+    #
+    # @param val [String]
+    #   the data
+    # @return [Object]
+    #   ruby object
+    def convert_to_ruby(val)
+      @to_ruby.call(val)
+    end
+
+    # Convert the ruby object to data.
+    #
+    # @param val [Object]
+    #   ruby object
+    # @return [String]
+    #   data
+    def convert_from_ruby(val)
+      @from_ruby.call(val)
+    end
+
+    # field type +bool+
+    BOOL = Type.define(:bool) {
+      to_ruby {|val| val == "true"}
+      from_ruby {|val| val.to_s}
+    }
+
+    # field type +int+
+    INT = Type.define(:int) {
+      to_ruby {|val| val.to_i}
+      from_ruby {|val| val.to_s}
+    }
+
+    # field type +float+
+    FLOAT = Type.define(:float) {
+      to_ruby {|val| val.to_f}
+      from_ruby {|val| val.to_s}
+    }
+
+    # field type +string+
+    STRING = Type.define(:string) {
+      to_ruby {|val| val}
+      from_ruby {|val| val.to_s}
+    }
+
+    # field type +symbol+
+    SYMBOL = Type.define(:symbol) {
+      to_ruby {|val| val.to_sym}
+      from_ruby {|val| val.to_s}
+    }
+
+    # field type +time+
+    TIME = Type.define(:time) {
+      to_ruby {|val| DateTime.parse(val)}
+      from_ruby {|val| val.strftime("%Y-%m-%d %H:%M:%S")}
+    }
+
+    # field type +date+
+    DATE = Type.define(:date) {
+      to_ruby {|val| Date.parse(val)}
+      from_ruby {|val| val.strftime("%Y-%m-%d")}
+    }
+  end
+
+  # standard type list that includes
+  # - bool
+  # - int
+  # - float
+  # - string
+  # - symbol
+  # - time
+  # - date
+  STANDARD_TYPES = [
+    Type::BOOL,
+    Type::INT,
+    Type::FLOAT,
+    Type::STRING,
+    Type::SYMBOL,
+    Type::TIME,
+    Type::DATE
+  ]
+end