omnis 0.0.1 → 0.1.0

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :cli => "--color --format nested --fail-fast", :notification => true,
+               :run_all => { :cli => "--color --fail-fast" } do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Turnip features and steps
+  # watch(%r{^spec/acceptance/(.+)\.feature$})
+  # watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/README.md

@@ -1,6 +1,135 @@
 # Omnis
+The goal is to simplify standard and repetetive queries to Mongo and presenting their results.  
+To do this Omnis provides a Query and a Transformer, both can be configured using a DSL.
 
-TODO: Write a gem description
+## Query
+Converts a params Hash into Operators to be able to easily build queries against databases et al. This is a generic way to process incoming parameters.
+
+```ruby
+{ "ref_anixe" => "1abc"}
+```
+becomes
+```ruby
+Matches.new(:ref_anixe, "1abc")
+```
+
+Example:
+```ruby
+class SomeQuery
+  include Omnis::Query
+
+  def self.parse_date(params, name)
+    param = params[name]
+    return nil if param.nil?
+    time = Time.parse(param)
+    Between.new(name, time.getlocal.beginning_of_day..time.getlocal.end_of_day)
+  end
+
+  param :ref_anixe, Matches
+  param :passenger, Equals
+  param(:date, Between) {|params| self.parse_date(params, :date) }
+end
+```
+
+If a lambda used for extraction returns `nil`, the parameter will be removed.
+
+Params also support defaults as values or as lambdas which will be executed at the time the extraction of the values happens. This way you can build pre-defined queries and if required only override some values. The difference to normal blocks for extraction is that, the latter is not called if the param is not in the inputs - in this case the default will be used.
+
+```ruby
+  param :date_from, Between, :default => Between.new("services.date_from", tomorrow.beginning_of_day..tomorrow.end_of_day)
+  param :contract,  Matches, :default => "^wotra."
+```
+
+## MongoQuery
+This covers a standard use case where you have a bunch of params in a Hash, for instance from a web request and you need validation, and transformation of the incoming values.  
+No actual calls to mongo are done.
+
+Example:
+```ruby
+class BookingQuery
+  include Omnis::MongoQuery
+
+  # collection Mongo::Connection.new['bms']['bookings'] # planned!?
+
+  param :ref_anixe,   Equals
+  param :contract,    Matches
+  param :description, Matches
+  param :status,      Matches
+  param :product,     BeginsWith
+  param :agency,      Equals
+
+  # if this param is in the query, fetch the field "ref_customer"
+  param :ref_customer, Matches, :field => "ref_customer"
+
+  # those fields are always fetched
+  fields   %w[ref_anixe contract description status product agency passengers date_status_modified services]
+end
+```
+
+Usage:
+```ruby
+query = BookingQuery.new("ref_anixe" => "1abc", "product" => "HOT")
+mongo = query.to_mongo
+Mongo::Connection.new['bms']['bookings'].find(mongo.selector, mongo.opts)
+```
+
+## Transformer
+Transforms some data into another form of (flattened) data. Extractors can be used to get values from the data source.  
+If the first parameter of a property denotes the output field, the second is a string which is passed as argument to the extractor.
+
+Example:
+```ruby
+class BookingTransformer
+  include Omnis::DataTransformer
+  extractor Omnis::NestedHashExtractor.new
+
+  property :ref_anixe,    "ref_anixe"
+  property :ref_customer, "ref_customer"
+  property :status,       "status"
+  property(:passenger)     {|doc| Maybe(doc)['passengers'].map {|v| v.first.values.slice(1..2).join(' ') }.or('Unknown').fetch.to_s }
+  property :date          "date_status_modified", :default => Time.at(0), :format => ->v { v.to_s(:date) }
+  property :description,  "description"
+  property :product,      "product"
+  property :contract,     "contract"
+  property :agency,       "agency"
+  property :date_from,    "services.0.date_from", :default => "n/a", :format => ->v { v.to_s(:date) }
+  property :date_to,      "services.0.date_to",   :default => "n/a", :format => ->v { v.to_s(:date) }
+end
+```
+
+Usage:
+```ruby
+transformer = BookingTransformer.new
+transformer.transform(doc)
+```
+This will produce a Hash like `{:ref_anixe => "1abc", :status => "book_confirmed" ... }`
+
+If you provide blocks for all properties, an Extractor is not required
+
+```ruby
+class ExtractorlessTransformer
+  include Omnis::DataTransformer
+  property(:ref) {|src| src["ref_anixe"] }
+end
+```
+
+If you provide a `#to_object(hash)` method in the Transformer definition, it will be used to convert the output Hash into the object of you desire.
+
+## Putting it all together
+
+```ruby
+query       = BookingQuery.new("ref_anixe" => "1abc", "product" => "HOT").to_mongo
+transformer = BookingTransformer.new.to_proc
+collection  = Mongo::Connection.new['bms']['bookings']
+
+table       = collection.find(query.selector, query.opts.merge(:transformer => transformer))
+
+table = Omnis::MongoTable.new(connection, params, BookingQuery, BookingTransformer)
+
+table.call.each do |row|
+  row.
+end
+```
 
 ## Installation
 

data/lib/omnis.rb

@@ -1,5 +1,9 @@
 require "omnis/version"
 
-module Omnis
-  # Your code goes here...
-end
+require 'active_support/core_ext/hash'
+require 'omnis/nested_hash_extractor'
+require 'omnis/transformer'
+require 'omnis/operators'
+require 'omnis/query'
+require 'omnis/mongo_query'
+require 'omnis/mongo_report'

data/lib/omnis/mongo_query.rb

@@ -0,0 +1,79 @@
+require 'ostruct'
+
+module Omnis
+  module MongoQuery
+    include Omnis::Query
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      include Omnis::Query::ClassMethods
+
+      attr_reader :page_param_name, :items_per_page
+      def field_list
+        @fields ||= []
+      end
+      def fields(list)
+        field_list.concat(list)
+      end
+
+      def page(page_param_name, opts={})
+        @page_param_name = page_param_name
+        @items_per_page  = opts[:items_per_page] || 10
+      end
+    end
+
+    module InstanceMethods
+      include Omnis::Operators
+
+      def to_mongo
+        extracted_params = extract
+        OpenStruct.new({ :selector => mongo_selector(extracted_params),
+                         :opts     => mongo_opts(extracted_params)})
+      end
+
+      private
+      def page
+        return 0 unless @input_params.has_key? page_param_name
+        return @input_params[page_param_name].to_i - 1
+      end
+
+      def skip
+        page * items_per_page
+      end
+
+      def page_param_name
+        self.class.page_param_name || :page
+      end
+
+      def items_per_page
+        self.class.items_per_page || 20
+      end
+
+      def mongo_operator(operator)
+        case operator
+        when Equals;      operator.value
+        when Matches;     /#{operator.value}/i
+        when BeginsWith;  /^#{operator.value}/i
+        when Between;     { :'$gte' => operator.value.begin, :'$lt' => operator.value.end}
+        end
+      end
+
+      def mongo_selector(extracted_params)
+        Hash[extracted_params.map { |operator| [operator.key, mongo_operator(operator)] }]
+      end
+
+      def mongo_opts(extracted_params)
+        params_with_extra_fields = extracted_params.collect(&:opts).select {|e| e.has_key? :field}
+        extra_fields = params_with_extra_fields.map {|e| e[:field]}
+        fields = self.class.field_list.concat(extra_fields)
+        { :limit => items_per_page, :skip => skip, :fields => fields }
+      end
+    end
+  end
+end
+

data/lib/omnis/mongo_report.rb

@@ -0,0 +1,13 @@
+module Omnis
+  module MongoReport
+    def find
+      @input.find(@query.selector, @query.opts.merge(:transformer => @transformer))
+    end
+
+    def run
+      find.each do |row|
+        @output.save(row)
+      end
+    end
+  end
+end

data/lib/omnis/nested_hash_extractor.rb

@@ -0,0 +1,29 @@
+require 'monadic'
+
+module Omnis
+  class NestedHashExtractor
+    # returns a lambda which extracts a value from a nested hash
+    def extractor(path)
+      raise ArgumentError("path to extract must be a string") unless String === path
+      expr = "source#{from_dot_path(path)} rescue Nothing"
+      ->source { eval(expr) }
+    end
+
+    private
+    # convert from a path to a ruby expression (as string)
+    def from_dot_path(path)
+      return nil if path.nil?
+      path.split('.').map {|i| field(i) }.join
+    end
+
+    def field(f)
+      return '['  << f << ']' if is_i?(f)
+      return '.fetch("' << f << '", Nothing)'
+    end
+
+    # checks if the string is a number
+    def is_i?(s)
+     !!(s =~ /^[-+]?[0-9]+$/)
+   end
+ end
+end

data/lib/omnis/operators.rb

@@ -0,0 +1,36 @@
+module Omnis
+  module Operators
+    class NullOperator
+      attr_reader :key, :value, :opts
+      def initialize(key, value, opts={})
+        @key, @value, @opts = key, value, opts
+      end
+
+      def ==(other)
+        return false unless other.is_a? self.class
+        return false unless @key == other.key
+        @value == other.value
+      end
+
+      def to_s
+        klas = self.class.to_s.downcase.split('::')[-1]
+        "#{@key.to_s} #{klas} #{@value}"
+      end
+    end
+
+    class Matches < NullOperator
+    end
+
+    class Equals < NullOperator
+    end
+
+    class Gte < NullOperator
+    end
+
+    class Between < NullOperator
+    end
+
+    class BeginsWith < NullOperator
+    end
+  end
+end

data/lib/omnis/query.rb

@@ -0,0 +1,67 @@
+require 'active_support/core_ext/hash'
+
+module Omnis
+  module Query
+
+    class Param
+      attr_reader :name, :operator
+      def initialize(name, operator, opts={}, &extractor)
+        # raise ArgumentError("operator must be a descendant of Omnis::Operators::NullOperator") unless operator.is_a? Omnis::Operators::NullOperator
+        extractor ||= ->params { params[name] }
+        @name, @operator, @opts, @extractor = name, operator, opts, extractor
+      end
+
+      def ==(other)
+        return false unless other.is_a? self.class
+        return false unless @name == other.name
+        @operator == other.operator
+      end
+
+      # extracts the value for a param, using the extractor lamba or the default value
+      def extract(params)
+        value = @extractor.(params) || default
+        return value if value.is_a? Omnis::Operators::NullOperator
+        return @operator.new(@name, value, @opts) unless value.nil?
+      end
+
+      def default
+        expr = @opts[:default]
+        return expr.call if expr.is_a? Proc
+        return expr
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+        include Omnis::Operators
+      end
+    end
+
+    module ClassMethods
+      def params
+        @params ||= {}
+      end
+
+      def param(name, operator, opts={}, &block)
+        Omnis::Query::Param.new(name, operator, opts, &block).tap do |param|
+          params[param.name] = param
+        end
+      end
+    end
+    module InstanceMethods
+      def initialize(input_params)
+        @input_params = input_params.symbolize_keys
+      end
+
+      def fetch(name)
+        self.class.params.fetch(name).extract(@input_params)
+      end
+
+      def extract
+        self.class.params.map { |k,v| v.extract(@input_params) }.compact
+      end
+    end
+  end
+end

data/lib/omnis/transformer.rb

@@ -0,0 +1,86 @@
+module Omnis
+  module Transformer
+    class Property
+      attr_reader :name, :expr, :opts
+      def initialize(name, expr, opts, extractor)
+        @name, @expr, @opts, @extractor = name, expr, opts, extractor
+      end
+
+      def default
+        opts[:default]
+      end
+
+      def format
+        opts[:format]
+      end
+
+      def extract(source)
+        @extractor.call(source)
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      def properties
+        @properties ||= {}
+      end
+
+      # if an expr is provided it will be passed to the configured extractor,
+      # otherwise a block is required
+      def property(name, expr=nil, opts={}, &block)
+        raise ArgumentError if (expr.nil? && block.nil?)
+
+        xtr = case expr
+              when String; @extractor.extractor(expr)
+              when nil   ; block
+              end
+
+        Omnis::Transformer::Property.new(name, expr, opts, xtr).tap do |prop|
+          properties[prop.name] = prop
+        end
+      end
+
+      def extractor(obj)
+          @extractor = obj
+      end
+
+      def extract(source, expr)
+        @extractor.extractor(expr).call(source)
+      end
+    end
+
+    module InstanceMethods
+      def __extract(property, source)
+        value = property_value(property, source)
+        if property.format
+          property.format.call(value)
+        else
+          value
+        end
+      end
+
+      def property_value(property, source)
+        value = property.extract(source)
+        return property.default if property.default && (value == Nothing || value.nil?)
+        return value
+      end
+
+      def transform(source)
+        result = Hash[self.class.properties.map do |k, v| [k, __extract(v, source)] end]
+        respond_to?(:to_object) ? to_object(result) : result
+      end
+
+      # provides a Proc to the transform method, for use e.g. with Mongo documents
+      # If you want to cache a transformer for reuse, you can cache just this Proc
+      def to_proc
+        method(:transform).to_proc
+      end
+    end
+  end
+end

data/lib/omnis/version.rb

@@ -1,3 +1,3 @@
 module Omnis
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/omnis.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |gem|
   gem.version       = Omnis::VERSION
   gem.authors       = ["Piotr Zolnierek"]
   gem.email         = ["pz@anixe.pl"]
-  gem.description   = %q{Helps a read-only ORM kind-of}
+  gem.description   = %q{Helps with a read-only ORM kind-of, more useful than the description}
   gem.summary       = %q{see above}
   gem.homepage      = "http://github.com/pzol/omnis"
 
@@ -16,11 +16,15 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+  gem.add_dependency             'activesupport'
+  gem.add_dependency             'bson_ext', '>=1.7.0'
+  gem.add_dependency             'monadic'
+  gem.add_dependency             'mongo', '>=1.7.0'
   gem.add_development_dependency 'rspec', '>=2.9.0'
   gem.add_development_dependency 'guard'
   gem.add_development_dependency 'guard-rspec'
   gem.add_development_dependency 'guard-bundler'
   gem.add_development_dependency 'growl'
-  gem.add_development_dependency 'activesupport'
   gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rb-fsevent', '~> 0.9.1'
 end

data/spec/lib/omnis/mongo_query_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'omnis/operators'
+require 'omnis/query'
+require 'omnis/mongo_query'
+require 'active_support/core_ext/date/calculations'
+require 'active_support/core_ext/time/calculations'
+
+describe Omnis::MongoQuery do
+  class TestIntegrationQuery
+    include Omnis::MongoQuery
+
+    # collection Mongo::Connection.new['bms']['bookings']
+    def self.parse_date(params, name)
+      param = params[name]
+      return nil if param.nil?
+      time = Time.parse(param)
+      Between.new(name, time.beginning_of_day..time.end_of_day)
+    end
+
+    param :ref_anixe,   Equals
+    param(:date, Between) {|source| parse_date(source, :date)}
+    param :contract,    Matches
+    param :description, Matches
+    param :status,      Matches
+    param :product,     BeginsWith
+    param :agency,      Equals
+
+    page  :page, :items_per_page => 20
+
+    # those fields are always fetched
+    fields   %w[ref_anixe contract description status product agency passengers date_status_modified services]
+  end
+
+  it "works altogether" do
+    t = TestIntegrationQuery.new("ref_anixe" => "1abc", "contract" => "test", "product" => "HOT", "page" => "2", "date" => "2012-10-12")
+    t.to_mongo.selector.should == { :ref_anixe => "1abc",
+                                 :contract  => /test/i,
+                                 :product   => /^HOT/i,
+                                 :date      => { :'$gte' => Time.local(2012, 10, 12, 0, 0, 0), :'$lt' => Time.local(2012, 10, 12, 23, 59, 59, 999999.999)}
+                               }
+
+    fields = %w[ref_anixe contract description status product agency passengers date_status_modified services]
+    t.to_mongo.opts.should == { :limit => 20, :skip => 20, :fields => fields}
+  end
+
+  context 'fields' do
+    class TestFieldsQuery
+      include Omnis::MongoQuery
+
+      fields %w[ref_anixe status]
+      # if this param is in the query, fetch the field "ref_customer"
+      param :ref_customer, Matches, :field => "ref_customer"
+    end
+
+    it 'extra field not requested when param not present' do
+      t = TestFieldsQuery.new({})
+      t.to_mongo.opts.should == { :limit => 20, :skip => 0, :fields => ['ref_anixe', 'status']}
+    end
+
+    it 'extra field is requested when param is in request' do
+      t = TestFieldsQuery.new({"ref_customer" => "123"})
+      t.to_mongo.opts.should == { :limit => 20, :skip => 0, :fields => ['ref_anixe', 'status', 'ref_customer']}
+    end
+  end
+
+  context 'paging' do
+    class TestPageDefaultQuery
+      include Omnis::MongoQuery
+    end
+
+    it "page default no page number given" do
+      t = TestPageDefaultQuery.new({})
+      t.to_mongo.opts.should == { :limit => 20, :skip => 0, :fields => []}
+    end
+    it "page defaults and page given" do
+      t = TestPageDefaultQuery.new({"page" => 2})
+      t.to_mongo.opts.should == { :limit => 20, :skip => 20, :fields => []}
+    end
+  end
+
+  context 'practical use case with predefined params' do
+    class TestHotelsWithDepartureTomorrowQuery
+      include Omnis::MongoQuery
+      def self.tomorrow
+        Time.new(2012, 10, 12, 22, 54, 38)
+      end
+
+      param :date_from, Between, :default => Between.new("services.date_from", tomorrow.beginning_of_day..tomorrow.end_of_day)
+      param :contract,  Matches, :default => "^wotra."
+      param :product,   Equals,  :default => "PACKAGE"
+      param :status,    Equals,  :default => "book_confirmed"
+
+      page :page, :items_per_page => 9999
+      fields %w[ref_anixe ref_customer status passengers date_status_modified description contract agency services]
+    end
+
+    it "should fill params with default" do
+      t = TestHotelsWithDepartureTomorrowQuery.new({})
+      m = p t.to_mongo
+      m.selector[:contract].should == /^wotra./i
+      m.selector[:product].should  == "PACKAGE"
+      m.selector[:status].should   == "book_confirmed"
+      m.selector['services.date_from'].should == {:'$gte' => Time.new(2012, 10, 12), :'$lt' => Time.local(2012, 10, 12, 23, 59, 59, 999999.999)}
+      m.opts[:limit].should  == 9999
+      m.opts[:skip].should   == 0
+      m.opts[:fields].should == ["ref_anixe", "ref_customer", "status", "passengers", "date_status_modified", "description", "contract", "agency", "services"]
+    end
+  end
+end

data/spec/lib/omnis/nested_hash_extractor_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'omnis/nested_hash_extractor'
+
+describe Omnis::NestedHashExtractor do
+  let(:xtr) { Omnis::NestedHashExtractor.new }
+  let(:doc) {
+    { "ref_anixe" => "1abc",
+      "contract" => "test",
+      "agency"   => nil,
+      "services" => [ { "date_from" => "2012-10-10"}]}
+  }
+
+  it "extracts values using a path" do
+    xtr.extractor("ref_anixe").call(doc).should == "1abc"
+    xtr.extractor("services.0.date_from").call(doc).should == "2012-10-10"
+    xtr.extractor("agency").call(doc).should be_nil
+  end
+
+  it "returns Nothing if an expression points to a non-existant key" do
+    xtr.extractor("ref_anixe").call({}).should == Nothing
+  end
+
+  it "returns Nothing for a nested path, if an exception would be raised" do
+    xtr.extractor("a.b.c").call({}).should == Nothing
+    xtr.extractor("a.(1]").call({}).should == Nothing
+  end
+
+  it "returns nil if the underlying value of a key is nil" do
+    xtr.extractor("agency").call(doc).should be_nil
+  end
+
+end

data/spec/lib/omnis/operators_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'omnis/operators'
+
+describe Omnis::Operators do
+  it 'supports equality' do
+    this = Omnis::Operators::NullOperator.new(:key, :value)
+    that = Omnis::Operators::NullOperator.new(:key, :value)
+    (this == that).should be_true
+
+    other = Omnis::Operators::NullOperator.new(:other, :value)
+    (other == this).should be_false
+
+    another = Omnis::Operators::NullOperator.new(:key, :another)
+    (another == this).should be_false
+  end
+
+  it 'should carry additional options' do
+    o = Omnis::Operators::NullOperator.new(:key, :value, {:k => 'v'})
+    expect(o.key).to   eq(:key)
+    expect(o.value).to eq(:value)
+    expect(o.opts).to  eq({:k => 'v'})
+  end
+end

data/spec/lib/omnis/query_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'omnis/operators'
+require 'omnis/query'
+require 'active_support/core_ext/hash'
+
+describe Omnis::Query::Param do
+  it "supports equality" do
+    Omnis::Query::Param.new(:param, Omnis::Operators::Matches).should == Omnis::Query::Param.new(:param, Omnis::Operators::Matches)
+    Omnis::Query::Param.new(:param, Omnis::Operators::Between).should_not == Omnis::Query::Param.new(:param, Omnis::Operators::Matches)
+  end
+end
+
+describe Omnis::Query do
+  class TestBookingParams
+    include Omnis::Query
+
+    def self.parse_date(params, name)
+      param = params[name]
+      return nil if param.nil?
+      time = Time.parse(param)
+      Between.new(name, time.getlocal.beginning_of_day..time.getlocal.end_of_day)
+    end
+
+    param :ref_anixe, Matches
+    param :passenger, Equals
+    param(:date, Between) {|params| parse_date(params, :date) }
+  end
+
+  it "allows to fetch a single param" do
+    t = TestBookingParams.new({"ref_anixe" => "1abc"})
+    t.fetch(:ref_anixe).should == Omnis::Operators::Matches.new(:ref_anixe, "1abc")
+  end
+
+  it "allows to extract all at once" do
+    t = TestBookingParams.new({"ref_anixe" => "1abc"})
+    t.extract.should == [Omnis::Operators::Matches.new(:ref_anixe, "1abc")]
+  end
+
+  it "allows using blocks for extracing params" do
+    t = TestBookingParams.new({"date" => "2012-10-02"})
+    value = t.fetch(:date).value
+    value.begin.should be_eql Time.local(2012, 10, 02, 0, 0, 0)
+    value.end.should == Time.local(2012, 10, 02, 23, 59, 59, 999999.999)
+  end
+
+  it "returns default values even if not in the params" do
+    class TestDefaultParams
+      include Omnis::Query
+      param :contract,  Matches, :default => "test"
+    end
+
+    t = TestDefaultParams.new({})
+    t.fetch(:contract).value.should == "test"
+  end
+
+  it "should accept a lambda as default" do
+    class TestDefaultsWithLambdaParams
+      include Omnis::Query
+      param :contract, Equals, :default => -> { :angry_nerds }
+    end
+
+    t = TestDefaultsWithLambdaParams.new({})
+    t.fetch(:contract).value.should == :angry_nerds
+  end
+end

data/spec/lib/omnis/transformer_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'ostruct'
+require 'monadic'
+require 'omnis/nested_hash_extractor'
+require 'omnis/transformer'
+
+describe Omnis::Transformer do
+  class TestTransformer
+    include Omnis::Transformer
+    extractor Omnis::NestedHashExtractor.new
+
+    property :ref,       "ref_anixe"
+    property(:date_from) {|source| Maybe(extract(source, "services.0.date_from")).or(Time.at(0)).fetch }
+    property :date_to,   "services.0.date_to",   :default => Time.at(0), :format => ->v { v.strftime("%Y-%m-%d") }
+    property :agency,    "agency",               :default => "000000"
+  end
+
+  let(:doc) {
+    { "ref_anixe" => "1abc",
+      "contract" => "test",
+      "agency"   => nil,
+      "services" => [ { "date_from" => "2012-10-10"}]}
+  }
+
+  it "should read values from the doc" do
+    t = TestTransformer.new
+    t.transform(doc).should == { :ref => "1abc", :date_from => "2012-10-10", :date_to => "1970-01-01", :agency => "000000" }
+  end
+
+  it "should support blocks in properties, without a defined extractor" do
+    class TestTransformerWithBlock
+      include Omnis::Transformer
+      property(:ref) {|src| Maybe(src)["ref_anixe"].fetch }
+    end
+
+    t = TestTransformerWithBlock.new
+    t.transform(doc).should == { :ref => "1abc" }
+  end
+
+  it "should raise an ArgumentError if no block and no expression provided" do
+    expect {
+      class TestTransformerInvalid
+        include Omnis::Transformer
+        property :ref
+      end
+    }.to raise_error ArgumentError
+  end
+
+  it "uses a #to_object method if provided to convert the resulting Hash into an Object" do
+    class TestTransformerWithToObject
+      include Omnis::Transformer
+      property(:ref) {|src| src["ref_anixe"]}
+      def to_object(hash)
+        OpenStruct.new(hash)
+      end
+    end
+    t = TestTransformerWithToObject.new
+    t.transform(doc).should == OpenStruct.new(ref: "1abc")
+  end
+
+  it 'provides a tranformer lambda' do
+    class TestXformer
+      include Omnis::Transformer
+      property(:ref) {|src| src['ref_anixe']}
+    end
+    t = TestXformer.new
+    xformer = t.to_proc
+    xformer.should be_a Proc
+    xformer.({"ref_anixe" => "2two"}).should == {:ref => "2two"}
+  end
+end

data/spec/spec.rake

@@ -7,8 +7,8 @@ SPEC_SUITES = [
 
   { :id => :acceptance,
     :title => 'acceptance',
-    :files => %w(spec_acceptance/acceptance/**/*_spec.rb),
-    :opts => '-I spec_acceptance' },
+    :files => %w(spec/acceptance/**/*_spec.rb),
+    :opts => '-I spec/acceptance' },
 ]
 
 

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
 require 'bundler/setup'
 Bundler.require :test
+
+ENV['TZ'] = "CET" # make sure all tests are in the same timezone
 $LOAD_PATH << File.expand_path('../../lib', __FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnis
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,72 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-04 00:00:00.000000000 Z
+date: 2012-10-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: monadic
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -92,7 +156,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -108,22 +172,22 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rb-fsevent
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-description: Helps a read-only ORM kind-of
+        version: 0.9.1
+description: Helps with a read-only ORM kind-of, more useful than the description
 email:
 - pz@anixe.pl
 executables: []
@@ -132,13 +196,24 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/omnis.rb
+- lib/omnis/mongo_query.rb
+- lib/omnis/mongo_report.rb
+- lib/omnis/nested_hash_extractor.rb
+- lib/omnis/operators.rb
+- lib/omnis/query.rb
+- lib/omnis/transformer.rb
 - lib/omnis/version.rb
 - omnis.gemspec
-- readme.rb
+- spec/lib/omnis/mongo_query_spec.rb
+- spec/lib/omnis/nested_hash_extractor_spec.rb
+- spec/lib/omnis/operators_spec.rb
+- spec/lib/omnis/query_spec.rb
+- spec/lib/omnis/transformer_spec.rb
 - spec/spec.rake
 - spec/spec_helper.rb
 homepage: http://github.com/pzol/omnis
@@ -153,12 +228,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3696760382807505073
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3696760382807505073
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -166,5 +247,10 @@ signing_key:
 specification_version: 3
 summary: see above
 test_files:
+- spec/lib/omnis/mongo_query_spec.rb
+- spec/lib/omnis/nested_hash_extractor_spec.rb
+- spec/lib/omnis/operators_spec.rb
+- spec/lib/omnis/query_spec.rb
+- spec/lib/omnis/transformer_spec.rb
 - spec/spec.rake
 - spec/spec_helper.rb

data/readme.rb

@@ -1,49 +0,0 @@
-class BookingQuery
-  include Omnis::MongoQuery
-
-  collection Mongo::Connection.new['bms']['bookings']
-
-  def parse_date(value)
-    case result = Time.parse(value) rescue Chronic.parse(value, :guess => false)
-      when Time;          Between.new(m, result.getlocal.beginning_of_day..result.getlocal.end_of_day)
-      when Chronic::Span; Between.new(m, result)
-      else nil
-    end
-  end
-
-  param    :contract, Matches
-  param    :date_from {|value| parse_date(value) }
-  param    :date_to   {|value| parse_date(value) }
-
-  fields   %w[ref_anixe ref_customer status passengers date_status_modified date_from date_to description product contract agency services]
-end
-
-class BookingTransformer
-  include Omnis::DataTransformer
-
-  def extract_passenger(doc)
-    ->doc { Maybe(doc)['passengers'].map {|v| v.first.values.slice(1..2).join(' ') }.or('Unknown').fetch.to_s }
-  end
-
-  property :ref_anixe,    "ref_anixe"
-  property :ref_customer, "ref_customer"
-  property :status,       "status"
-  property :passenger,    extract_passenger(doc)
-  property :date          "date_status_modified", :default => Time.at(0), :format => ->v { v.to_s(:date) }
-  property :description,  "description"
-  property :product,      "product"
-  property :contract,     "contract"
-  property :agency,       "agency"
-  property :date_from,    "services.0.date_from", :default => "n/a", :format => ->v { v.to_s(:date) }
-  property :date_to,      "services.0.date_to",   :default => "n/a", :format => ->v { v.to_s(:date) }
-
-  def to_object(doc)
-    OpenStruct.new(doc)
-  end
-end
-
-present BookingQuery.new(params), Foo.new(NestedHashExtractor.new)
-
-def present(query, transformer)
-  query.call(transformer)
-end