icss 0.1.3 → 0.3.2

data/lib/icss/protocol/code_asset.rb

@@ -0,0 +1,18 @@
+module Icss
+  module Meta
+    class CodeAsset
+      include Icss::ReceiverModel
+
+      field :name,      String
+      field :location,  String
+
+      def to_hash()
+        { :name => name, :location => location}
+      end
+
+      def to_json() to_hash.to_json ; end
+
+    end
+  end
+
+end

data/lib/icss/protocol/data_asset.rb

@@ -0,0 +1,23 @@
+module Icss
+  module Meta
+    class DataAsset
+      include Icss::ReceiverModel
+
+      field :name,      String
+      field :location,  String
+      # overriding ruby's deprecated but still present type attr on objects
+      attr_accessor :type
+      field :type,      String
+      field :doc,       String
+
+      def named? nm
+        name == nm
+      end
+
+      def to_hash()
+        { :name => name, :location => location, :type => type, :doc => doc }
+      end
+      def to_json() to_hash.to_json ; end
+    end
+  end
+end

data/lib/icss/protocol/license.rb

@@ -0,0 +1,41 @@
+module Icss
+  module Meta
+    class License
+      include Icss::ReceiverModel
+      include Icss::ReceiverModel::ActsAsCatalog
+
+      field :license_id,      String
+      field :title,           String
+      field :url,             String
+      field :description,     String
+      field :summary,         String
+      field :article_body,    String
+      
+      def fullname
+        license_id
+      end
+      
+      def name
+        license_id.split('.').last
+      end
+      alias_method :basename, :name
+
+      def self.catalog_sections
+        ['licenses']
+      end
+
+      def to_hash()
+        { :license_id => license_id,
+          :title => title,
+          :url => url,
+          :description => description,
+          :summary => summary,
+          :article_body => article_body }
+      end
+
+      def to_json() to_hash.to_json ; end
+
+    end
+  end
+
+end

data/lib/icss/protocol/source.rb

@@ -0,0 +1,37 @@
+module Icss
+  module Meta
+    class Source
+      include Icss::ReceiverModel
+      include Icss::ReceiverModel::ActsAsCatalog
+      
+      field :source_id,   String
+      field :title,       String
+      field :description, String
+      field :url,         String
+      
+      def fullname
+        source_id
+      end
+      
+      def name
+        source_id.split('.').last
+      end
+      alias_method :basename, :name
+
+      def self.catalog_sections
+        ['sources']
+      end
+
+      def to_hash()
+        { :source_id => source_id,
+          :title => title,
+          :description => description,
+          :url => url }
+      end
+
+      def to_json() to_hash.to_json ; end
+
+    end
+  end
+
+end

data/lib/icss/protocol/target.rb

@@ -0,0 +1,68 @@
+module Icss
+
+  #
+  # Instantiates an array of target objects
+  #
+  class TargetListFactory
+    def self.receive target_info_list, target_name
+      klass = "Icss::#{target_name.to_s.camelize}Target".constantize
+      target_info_list.map{|target_info| klass.receive(target_info)}
+    end
+  end
+
+  class Target
+    include Icss::ReceiverModel
+    field :name, String
+    alias_method :basename, :name
+  end
+
+  class MysqlTarget < Target
+    field :data_assets,     Array, :items => String
+    field :database,        String
+    field :table_name,      String
+  end
+
+  class ApeyeyeTarget < Target
+    field :code_assets,     Array, :items => String
+  end
+
+  class HbaseTarget < Target
+    field :data_assets,     Array, :items => String
+    field :table_name,      String
+    field :column_families, Array, :items => String
+    field :column_family,   String
+    field :loader,          String
+    field :id_field,        String
+  end
+
+  class ElasticSearchTarget < Target
+    field :data_assets,     Array, :items => String
+    field :index_name,      String
+    field :id_field,        String
+    field :object_type,     String
+    field :loader,          String
+  end
+
+  class GeoIndexTarget < Target
+    field :data_assets,     Array, :items => String
+    field :table_name,      String
+    field :min_zoom,        Integer
+    field :max_zoom,        Integer
+    field :chars_per_page,  Integer
+    field :sort_field,      String
+  end
+
+  class CatalogTarget < Target
+    field :name,            String
+    field :license,         String
+    field :title,           String
+    field :link,            String
+    field :description,     String
+    field :owner,           String
+    field :price,           Float
+    field :tags,            Array, :items => String
+    field :messages,        Array, :items => String
+    field :packages,        Array, :items => { :type => Hash, :values => Object }
+  end
+
+end

data/lib/icss/receiver_model.rb

@@ -0,0 +1,24 @@
+module Icss
+  module ReceiverModel
+    include Gorillib::Hashlike
+    include Icss::ReceiverModel::ActsAsHash
+    include Gorillib::Hashlike::TreeMerge
+    include Icss::ReceiverModel::ActsAsLoadable
+    include Icss::Meta::RecordModel
+    include Icss::ReceiverModel::ActsAsTuple
+
+    module ClassMethods
+      include Icss::Meta::RecordType
+      include Icss::ReceiverModel::ActsAsTuple::ClassMethods
+    end
+
+    # put all the things in ClassMethods at class level
+    def self.included base
+      base.class_eval do
+        include Icss::ReceiverModel::ActiveModelShim
+        extend  Icss::ReceiverModel::ClassMethods
+      end
+    end
+
+  end
+end

data/lib/icss/receiver_model/active_model_shim.rb

@@ -0,0 +1,36 @@
+require 'active_model'
+# require 'active_model/deprecated_error_methods'
+# require 'active_model/errors'
+# require 'active_model/naming'
+# require 'active_model/validator'
+# require 'active_model/translation'
+# require 'active_model/validations'
+# require 'active_support/i18n'
+# I18n.load_path << File.join(File.expand_path(File.dirname(__FILE__)), 'locale/en.yml')
+
+module Icss
+  module ReceiverModel
+
+    module ActiveModelShim
+
+      def to_model
+        self
+      end
+
+      def new_record?() true  end
+
+      def destroyed?()  false end
+
+      def errors
+        @_errors ||= ActiveModel::Errors.new(self)
+      end
+
+      def self.included(base)
+        base.class_eval do
+          extend  ActiveModel::Naming
+          include ActiveModel::Validations
+        end
+      end
+    end
+  end
+end

data/lib/icss/receiver_model/acts_as_catalog.rb

@@ -0,0 +1,170 @@
+require 'active_support/core_ext/module'
+
+# including class is required to implement the following methods:
+# * catalog_sections
+# * fullname
+
+# including module is required to additionally implement:
+# * receive (if not implemented)
+# * after_receiver (to register objects) 
+
+
+module Icss
+  module ReceiverModel
+    module ActsAsCatalog
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      #
+      # Register object in class's registry
+      #
+      def register(obj)
+        self.class.register(obj)
+      end
+      
+      module ClassMethods
+        include Icss::ReceiverModel::ActsAsLoadable::ClassMethods
+        
+        
+        #
+        # Include ActAsLoadable for file receivers
+        # Declare and initialize registry class/module variable to hash
+        # Set after_receiver(:register) for classes to register their objects
+        #
+        def self.extended(base)
+          base.class_eval do
+            if is_a?(Class)
+              include Icss::ReceiverModel::ActsAsLoadable::ClassMethods
+              class_attribute :registry
+              class_attribute :_catalog_loaded
+              after_receive(:register) do |hsh|
+                register(self)
+              end
+            elsif is_a?(Module)
+              mattr_accessor :registry
+              mattr_accessor :_catalog_loaded
+            end
+            self.registry = Hash.new
+          end
+        end
+        
+        #
+        # Add object to registry using fullname method as the identifier
+        #
+        
+        def register(obj)
+          registry[obj.fullname] = obj
+        end
+        
+        #
+        # Basic ActiveRecord inspired methods
+        # Name can include wildcards(*) for simple searching
+        #   - example: geo.*.location.*
+        #              matches anything with a namespace starting with 'geo'
+        #              and containing 'location'
+        #
+        
+        def all(name='*')
+          find(:all, name)
+        end
+        
+        def first(name='*')
+          find(:first, name)
+        end
+        
+        def last(name='*')
+          find(:last, name)
+        end
+        
+        #
+        # ActiveRecord inspired find method
+        # Params:
+        #   1. :all, :first, :last, or registry identifier(ignores wildcards to force exact match)
+        #   2. registry name with wildcards(*)
+        #         - example: geo.*.location.*
+        #
+        
+        def find(name_or_find_type, name='*')  
+          if !self._catalog_loaded
+            self._catalog_loaded = true
+            load_catalog(true)
+          end
+                  
+          method_name = case name_or_find_type
+            when :all then :to_a
+            when :first then :first
+            when :last then :last
+            else
+              # If exact match not in registry, try looking in file catalog
+              result = (find_in_registry(name_or_find_type, :exact_match => true) || load_files_from_catalog(name_or_find_type, :exact_match => true))
+              raise Icss::NotFoundError, "Cannot find #{name_or_find_type}" if result.nil?
+              return result
+          end
+
+          # If not in registry, try looking in file catalog
+          (find_in_registry(name) || load_files_from_catalog(name)).send method_name
+        end
+        
+        def load_from_catalog(fullname)
+          filepath = fullname.to_s.gsub(/(\.icss\.yaml)?$/,'').gsub(/\./, '/')
+          filenames = catalog_filenames(filepath, [''])
+          filenames.each{|filename| receive_from_file(filename) }.compact
+        end
+        
+      private
+        #
+        # Search registry for matching objects
+        # Return single object for exact_match=true
+        #
+        def find_in_registry(name, args={})
+          return registry[name] if args.symbolize_keys[:exact_match]
+          
+          name = name.to_s.gsub('*', '[^\./]*').gsub(/\.\//, '\.').gsub(/\*$/, '.+') if name.include?('*')
+          name_regexp = Regexp.new("^#{name}$", true)
+          registry.select{|k, v| k.match(name_regexp) }.values
+        end
+        
+        #
+        # Load files from catalog files
+        # Namespaces used to correspond to directories
+        # Load single file for exact_match=true
+        # 
+        def load_files_from_catalog(name, args={})
+          # don't do anything if name is invalid format          
+          if args.symbolize_keys[:exact_match]
+            filename = catalog_filenames(name.to_s.gsub(/\./, '/'))[0]
+            receive_from_file(filename) if filename
+          elsif /\A([A-Za-z_\*]\w*\.?)+\Z/ === name
+            filename = name.to_s.gsub(/(\.icss\.yaml)?$/,'').gsub(/\./, '/').gsub(/\*$/, '**/*')
+            filenames = catalog_filenames(filename)
+            filenames.collect{|filename| receive_from_file(filename) } unless filenames.empty?
+          end
+          # Return object/s from registry after loading files
+          # Useful for unexpected file contents / protocols containing many types
+          find_in_registry(name, args)
+        end
+              
+        #
+        # Expand filenames to full paths using catalog_root, catalog_sections, and provided filename
+        #
+        def catalog_filenames(filename='*',catalog_sections=catalog_sections)
+          catalog_sections.collect{ |section|
+            Dir[File.join(Settings[:catalog_root], section, filename + '.icss.yaml')] }.flatten
+        end
+    
+        #
+        # Conditional empty registry and load all found files
+        #
+        def load_catalog(flush=false)
+          flush_registry if flush
+          load_files_from_catalog('*')
+        end
+        
+        def flush_registry
+          registry.clear
+        end
+      end
+    end
+  end
+end

data/lib/icss/receiver_model/acts_as_hash.rb

@@ -0,0 +1,177 @@
+require 'gorillib/hashlike'
+
+module Icss
+  module ReceiverModel
+
+    #
+    # Makes an Icss::RecordModel behave mostly like a hash.
+    #
+    # By default, the hashlike methods iterate over the fields: instance #keys
+    # delegates to self.class.field_names. All methods are defined naturally on
+    # [], []= and has_key? so the interface is well-guarded.
+    #
+    # in addition to the below, by including Enumerable, this also adds
+    #
+    #     :each_cons, :each_entry, :each_slice, :each_with_index, :each_with_object,
+    #     :map, :collect, :collect_concat, :entries, :to_a, :flat_map, :inject, :reduce,
+    #     :group_by, :chunk, :cycle, :partition, :reverse_each, :slice_before, :drop,
+    #     :drop_while, :take, :take_while, :detect, :find, :find_all, :find_index, :grep,
+    #     :all?, :any?, :none?, :one?, :first, :count, :zip :max, :max_by, :min, :min_by,
+    #     :minmax, :minmax_by, :sort, :sort_by
+    #
+    # As opposed to hash, does *not* define
+    #
+    #   default, default=, default_proc, default_proc=, shift, flatten, compare_by_identity
+    #   compare_by_identity? rehash
+    #
+    module ActsAsHash
+
+      # Hashlike#[]
+      #
+      # Element Reference -- Retrieves the value stored for +key+.
+      #
+      # In a normal hash, a default value can be set; none is provided here.
+      #
+      # Delegates to self.send(key)
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh[:a] # => 100
+      #     hsh[:c] # => nil
+      #
+      # @param  key [Object] key to retrieve
+      # @return [Object] the value stored for key, nil if missing
+      #
+      def [](key)
+        key = convert_key(key)
+        self.send(key)
+      end
+
+      # Hashlike#[]=
+      # Hashlike#store
+      #
+      # Element Assignment -- Associates the value given by +val+ with the key
+      # given by +key+.
+      #
+      # key should not have its value changed while it is in use as a key. In a
+      # normal hash, a String passed as a key will be duplicated and frozen. No such
+      # guarantee is provided here
+      #
+      # Delegates to self.send("key=", val)
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh[:a] = 9
+      #     hsh[:c] = 4
+      #     hsh    # => { :a => 9, :b => 200, :c => 4 }
+      #
+      #     hsh[key] = val                         -> val
+      #     hsh.store(key, val)                    -> val
+      #
+      # @param  key [Object] key to associate
+      # @param  val [Object] value to associate it with
+      # @return [Object]
+      #
+      def []=(key, val)
+        key = convert_key(key)
+        self.send("#{key}=", val) if respond_to?("#{key}=")
+        val
+      end
+
+      # Hashlike#delete
+      #
+      # Deletes and returns the value from +hsh+ whose key is equal to +key+. If the
+      # optional code block is given and the key is not found, pass in the key and
+      # return the result of +block+.
+      #
+      # In a normal hash, a default value can be set; none is provided here.
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh.delete(:a)                            # => 100
+      #     hsh.delete(:z)                            # => nil
+      #     hsh.delete(:z){|el| "#{el} not found" }   # => "z not found"
+      #
+      # @overload hsh.delete(key)                  -> val
+      #   @param  key [Object] key to remove
+      #   @return [Object, Nil] the removed object, nil if missing
+      #
+      # @overload hsh.delete(key){|key| block }    -> val
+      #   @param  key [Object] key to remove
+      #   @yield  [Object] called (with key) if key is missing
+      #   @yieldparam key
+      #   @return [Object, Nil] the removed object, or if missing, the return value
+      #     of the block
+      #
+      def delete(key, &block)
+        key = convert_key(key)
+        if has_key?(key)
+          val = self[key]
+          self.send(:remove_instance_variable, "@#{key}")
+          val
+        elsif block_given?
+          block.call(key)
+        else
+          nil
+        end
+      end
+
+      # Hashlike#keys
+      #
+      # Returns a new array populated with the keys from this hashlike.
+      #
+      # @see Hashlike#values.
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200, :c => 300, :d => 400 }
+      #     hsh.keys   # => [:a, :b, :c, :d]
+      #
+      # @return [Array] list of keys
+      #
+      def keys
+        self.class.field_names & instance_variables.map{|s| convert_key(s[1..-1]) }
+      end
+
+      #
+      # Returns a hash with each key set to its associated value.
+      #
+      # @example
+      #    my_hshlike = MyHashlike.new
+      #    my_hshlike[:a] = 100; my_hshlike[:b] = 200
+      #    my_hshlike.to_hash # => { :a => 100, :b => 200 }
+      #
+      # @return [Hash] a new Hash instance, with each key set to its associated value.
+      #
+      def attributes
+        {}.tap do |hsh|
+          each_pair do |key, val|
+            hsh[key] = val.respond_to?(:to_hash) ? val.to_hash : val
+          end
+        end
+      end
+
+      #
+      # Returns a hash with each key set to its associated value.
+      #
+      # Delegates to #attributes
+      #
+      def to_hash
+        attributes
+      end
+
+      def self.included(base)
+        base.class_eval do
+          include Gorillib::Hashlike
+        end
+      end
+
+    protected
+
+      def convert_key(key)
+        raise ArgumentError, "Keys for #{self.class} must be symbols, strings or respond to #to_sym" unless key.respond_to?(:to_sym)
+        key.to_sym
+      end
+    end
+
+  end
+end