ib-ruby 0.8.1 → 0.8.3

data/lib/ib-ruby/models/model.rb

@@ -1,105 +0,0 @@
-module IB
-  module Models
-
-    # Base class for tableless IB data Models extends ActiveModel API
-    class Model
-      extend ActiveModel::Naming
-      extend ActiveModel::Callbacks
-      include ActiveModel::Validations
-      include ActiveModel::Serialization
-      include ActiveModel::Serializers::Xml
-      include ActiveModel::Serializers::JSON
-
-      # IB Models can be either database-backed, or not
-      # require 'ib-ruby/db' # to make all IB models database-backed
-      # If you plan to persist only specific Models, select those subclasses here:
-      def self.for subclass
-        if DB # && [:contract, :order, :order_state].include? subclass
-          ActiveRecord::Base
-        else
-          Model
-        end
-      end
-
-      #attr_accessor :attributes
-
-      # If a opts hash is given, keys are taken as attribute names, values as data.
-      # The model instance fields are then set automatically from the opts Hash.
-      def initialize attributes={}, opts={}
-        run_callbacks :initialize do
-          error "Argument must be a Hash", :args unless attributes.is_a?(Hash)
-
-          self.attributes = default_attributes.merge(attributes)
-        end
-      end
-
-      # ActiveModel API (for serialization)
-
-      def attributes
-        @attributes ||= HashWithIndifferentAccess.new
-      end
-
-      def attributes= attrs
-        attrs.keys.each { |key| self.send("#{key}=", attrs[key]) }
-      end
-
-      # ActiveModel-style read/write_attribute accessors
-      def [] key
-        attributes[key.to_sym]
-      end
-
-      def []= key, val
-        # p key, val
-        attributes[key.to_sym] = val
-      end
-
-      def to_model
-        self
-      end
-
-      def new_record?
-        true
-      end
-
-      def save
-        valid?
-      end
-
-      alias save! save
-
-      ### ActiveRecord::Base association API mocks
-
-      def self.belongs_to model, *args
-        attr_accessor model
-      end
-
-      def self.has_one model, *args
-        attr_accessor model
-      end
-
-      def self.has_many models, *args
-        attr_accessor models
-
-        define_method(models) do
-          self.instance_variable_get("@#{models}") ||
-              self.instance_variable_set("@#{models}", [])
-        end
-      end
-
-      def self.find *args
-        []
-      end
-
-      ### ActiveRecord::Base callback API mocks
-
-      define_model_callbacks :initialize, :only => :after
-
-      ### ActiveRecord::Base misc
-
-      def self.serialize *properties
-      end
-
-
-    end # Model
-  end # module Models
-end # module IB

data/lib/ib-ruby/models/model_properties.rb

@@ -1,146 +0,0 @@
-require 'active_model'
-require 'active_support/concern'
-require 'active_support/hash_with_indifferent_access'
-
-module IB
-  module Models
-
-    # Module adds prop Macro and
-    module ModelProperties
-      extend ActiveSupport::Concern
-
-      def default_attributes
-        {:created_at => Time.now,
-         :updated_at => Time.now,
-        }
-      end
-
-      ### Instance methods
-
-      # Default presentation
-      def to_human
-        "<#{self.class.to_s.demodulize}: " + attributes.map do |attr, value|
-          "#{attr}: #{value}" unless value.nil?
-        end.compact.sort.join(' ') + ">"
-      end
-
-      # Comparison support
-      def content_attributes
-        HashWithIndifferentAccess[attributes.reject do |(attr, _)|
-          attr.to_s =~ /(_count)$/ ||
-              [:created_at, :updated_at, :type,
-               :id, :order_id, :contract_id].include?(attr.to_sym)
-        end]
-      end
-
-      # Update nil attributes from given Hash or model
-      def update_missing attrs
-        attrs = attrs.content_attributes unless attrs.kind_of?(Hash)
-
-        attrs.each { |attr, val| send "#{attr}=", val if send(attr).blank? }
-        self # for chaining
-      end
-
-      # Default Model comparison
-      def == other
-        content_attributes.inject(true) { |res, (attr, value)| res && other.send(attr) == value } &&
-            other.content_attributes.inject(true) { |res, (attr, value)| res && send(attr) == value }
-      end
-
-      included do
-
-        ### Class macros
-
-        def self.prop *properties
-          prop_hash = properties.last.is_a?(Hash) ? properties.pop : {}
-
-          properties.each { |names| define_property names, nil }
-          prop_hash.each { |names, type| define_property names, type }
-        end
-
-        def self.define_property names, body
-          aliases = [names].flatten
-          name = aliases.shift
-          instance_eval do
-
-            define_property_methods name, body
-
-            aliases.each do |ali|
-              alias_method "#{ali}", name
-              alias_method "#{ali}=", "#{name}="
-            end
-          end
-        end
-
-        def self.define_property_methods name, body={}
-          #p name, body
-          case body
-          when '' # default getter and setter
-            define_property_methods name
-
-          when Array # [setter, getter, validators]
-            define_property_methods name,
-                                    :get => body[0],
-                                    :set => body[1],
-                                    :validate => body[2]
-
-          when Hash # recursion base case
-            getter = case # Define getter
-                     when body[:get].respond_to?(:call)
-                       body[:get]
-                     when body[:get]
-                       proc { self[name].send "to_#{body[:get]}" }
-                     when VALUES[name] # property is encoded
-                       proc { VALUES[name][self[name]] }
-                          #when respond_to?(:column_names) && column_names.include?(name.to_s)
-                          #  # noop, ActiveRecord will take care of it...
-                          #  p "#{name} => get noop"
-                          #  p respond_to?(:column_names) && column_names
-            else
-              proc { self[name] }
-                     end
-            define_method name, &getter if getter
-
-            setter = case # Define setter
-                     when body[:set].respond_to?(:call)
-                       body[:set]
-                     when body[:set]
-                       proc { |value| self[name] = value.send "to_#{body[:set]}" }
-                     when CODES[name] # property is encoded
-                       proc { |value| self[name] = CODES[name][value] || value }
-            else
-              proc { |value| self[name] = value } # p name, value;
-                     end
-            define_method "#{name}=", &setter if setter
-
-            # Define validator(s)
-            [body[:validate]].flatten.compact.each do |validator|
-              case validator
-              when Proc
-                validates_each name, &validator
-              when Hash
-                validates name, validator.dup
-              end
-            end
-
-            # TODO define self[:name] accessors for :virtual and :flag properties
-
-          else # setter given
-            define_property_methods name, :set => body, :get => body
-          end
-        end
-
-        # Extending AR-backed Model class with attribute defaults
-        if defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
-          def initialize attributes={}, opts={}
-            super default_attributes.merge(attributes), opts
-          end
-        else
-          # Timestamps
-          prop :created_at, :updated_at
-        end
-
-      end # included
-    end # module ModelProperties
-  end # module Models
-end

data/lib/ib-ruby/models/option.rb

@@ -1,62 +0,0 @@
-require 'ib-ruby/models/contract'
-
-module IB
-  module Models
-    class Option < Contract
-
-      validates_numericality_of :strike, :greater_than => 0
-      validates_format_of :sec_type, :with => /^option$/,
-                          :message => "should be an option"
-      validates_format_of :local_symbol, :with => /^\w+\s*\d{6}[pcPC]\d{8}$|^$/,
-                          :message => "invalid OSI code"
-      validates_format_of :right, :with => /^put$|^call$/,
-                          :message => "should be put or call"
-
-      # For Options, this is contract's OSI (Option Symbology Initiative) name/code
-      alias osi local_symbol
-
-      def osi= value
-        # Normalize to 21 char
-        self.local_symbol = value.sub(/ /, ' '*(22-value.size))
-      end
-
-      # Make valid IB Contract definition from OSI (Option Symbology Initiative) code.
-      # NB: Simply making a new Contract with *local_symbol* (osi) property set to a
-      # valid OSI code works just as well, just do NOT set *expiry*, *right* or
-      # *strike* properties in this case.
-      # This class method provided as a backup and shows how to analyse OSI codes.
-      def self.from_osi osi
-
-        # Parse contract's OSI (OCC Option Symbology Initiative) code
-        args = osi.match(/(\w+)\s?(\d\d)(\d\d)(\d\d)([pcPC])(\d+)/).to_a.drop(1)
-        symbol = args.shift
-        year = 2000 + args.shift.to_i
-        month = args.shift.to_i
-        day = args.shift.to_i
-        right = args.shift.upcase
-        strike = args.shift.to_i/1000.0
-
-        # Set correct expiry date - IB expiry date differs from OSI if expiry date
-        # falls on Saturday (see https://github.com/arvicco/option_mower/issues/4)
-        expiry_date = Time.utc(year, month, day)
-        expiry_date = Time.utc(year, month, day-1) if expiry_date.wday == 6
-
-        new :symbol => symbol,
-            :exchange => "SMART",
-            :expiry => expiry_date.to_ib[2..7], # YYMMDD
-            :right => right,
-            :strike => strike
-      end
-
-      def default_attributes
-        super.merge :sec_type => :option
-        #self[:description] ||= osi ? osi : "#{symbol} #{strike} #{right} #{expiry}"
-      end
-
-      def to_human
-        "<Option: " + [symbol, expiry, right, strike, exchange, currency].join(" ") + ">"
-      end
-
-    end # class Option
-  end # module Models
-end # module IB