data_package 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 994a99398c2b3da0d8b872cd4b2382595c15fe29
+  data.tar.gz: 11992961b82bb22855285f7448752bab21c624de
+SHA512:
+  metadata.gz: bd0f314c6d0528939160c4363b2bc75c86b1d9a5a69092502a5a1c848c4b3d70514627d63dc6c5b3b788d46587e11cb47a02d8008edfb2ac6bd7afd076ce85ac
+  data.tar.gz: a93cd9c42b6cdd905a99ced9f1ac2f103419f5b47e8f123807e936aca0d2ca77f2da76ce193bc846e428765756c4c793121f98379d0030d65f7e4609a34a0fe4

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+
+rvm:
+  - 2.0.0
+
+script:
+  - CODECLIMATE_REPO_TOKEN=74137ef549933917f52507194af376c0a9b94e44f405e37157b0af247da2e6dc bundle exec rake

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mode-ruby.gemspec
+gemspec
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    data_package (0.0.1)
+      active_support
+      data_kit
+      rcsv
+      rubyzip
+      yajl-ruby
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    active_support (3.0.0)
+      activesupport (= 3.0.0)
+    activesupport (3.0.0)
+    codeclimate-test-reporter (0.2.0)
+      simplecov (>= 0.7.1, < 1.0.0)
+    data_kit (0.0.2)
+      rcsv
+      timeliness
+    diff-lcs (1.2.5)
+    docile (1.1.1)
+    multi_json (1.8.2)
+    rake (10.1.0)
+    rcsv (0.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    rubyzip (1.1.0)
+    simplecov (0.8.2)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    timeliness (0.3.7)
+    yajl-ruby (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  codeclimate-test-reporter
+  data_package!
+  rake
+  rspec
+  simplecov

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Mode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+Data Package
+============
+
+Library of classes and utilities for reading and writing data packages
+
+### Attribute Helpers
+
+#### Usage
+
+attr_required :name
+attr_required :path, :if => lamda {|obj|
+  obj.attr_missing?(:url) && obj.attr_missing?(:data)
+}
+
+attr_optional :title
+attr_optional :sources, :default => [], :key => 'sources',
+  :serialize => lambda { |source| source.collect(&:to_hash) }
+
+key is not required for attr_optional as it defaults to name of the attribute
+
+#### Instance Methods
+
+required_attrs => [...]
+optional_attrs => [...]
+serializable_attrs => [...]
+
+attr_required?(attr_name) #=> boolean
+
+valid? #=> boolean, Are all required fields present?
+
+attr_missing?(attr_name) #=> boolean
+attr_present?(attr_name) #=> boolean

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/data_package.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'data_package/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "data_package"
+  spec.version       = DataPackage::VERSION
+  spec.authors       = ["Mode Analytics"]
+  spec.email         = ["support@modeanalytics.com"]
+  spec.description   = %q{Library for reading and writing data packages}
+  spec.summary       = %q{Provides a set of classes for reading and writing data packages}
+  spec.homepage      = "http://www.modeanalytics.com/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # Runtime Dependencies
+  spec.add_runtime_dependency 'rcsv'
+  spec.add_runtime_dependency 'rubyzip'
+  spec.add_runtime_dependency 'yajl-ruby'
+  spec.add_runtime_dependency 'data_kit'
+  spec.add_runtime_dependency 'active_support'
+
+  # Development Dependencies
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+end

data/lib/attr_helper/base_attr.rb

@@ -0,0 +1,36 @@
+module AttrHelper
+  class BaseAttr
+    attr_reader :name
+    attr_reader :key
+    attr_reader :default
+    attr_reader :serialize
+
+    def initialize(name, options = {})
+      @name = name
+      @default = options[:default]
+      @key = options[:key] || name.to_s
+
+      if options[:serialize] == false
+        @serialize = false
+      else
+        @serialize = options[:serialize] || true
+      end
+    end
+
+    def serializable?
+      !@serialize.nil? && @serialize != false
+    end
+
+    def serialized(parent)
+      value = parent.send(name.to_sym) || default
+      
+      if @serialize == true
+        value
+      elsif @serialize.is_a?(Symbol)
+        parent.send(@serialize, value)
+      elsif serialize.is_a?(Proc)
+        @serialize.call(value)
+      end
+    end
+  end
+end

data/lib/attr_helper/required_attr.rb

@@ -0,0 +1,46 @@
+module AttrHelper
+  class RequiredAttr < BaseAttr
+    attr_reader :if_cond
+    attr_reader :unless_cond
+
+    def initialize(name, options = {})
+      super(name, options)
+      @if_cond = options[:if]
+      @unless_cond = options[:unless]
+    end
+
+    def required?(parent)
+      if conditions_empty?
+        true
+      else
+        included?(parent) && !excluded?(parent)
+      end
+    end
+
+    private
+
+    def conditions_empty?
+      if_cond.nil? && unless_cond.nil?
+    end
+
+    def included?(parent)
+      if if_cond.nil?
+        true
+      elsif if_cond.is_a?(Symbol)
+        parent.send(if_cond)
+      else
+        if_cond.call(parent)
+      end
+    end
+
+    def excluded?(parent)
+      if unless_cond.nil?
+        false
+      elsif unless_cond.is_a?(Symbol)
+        parent.send(unless_cond)
+      else
+        unless_cond.call(parent)
+      end
+    end
+  end
+end

data/lib/attr_helper/serialization.rb

@@ -0,0 +1,25 @@
+require 'yajl'
+
+module AttrHelper
+  module Serialization
+    def to_hash
+      {}.tap do |hsh|
+        attributes.each do |attribute|
+          next unless attribute.serializable?
+          
+          value = attribute.serialized(self)
+
+          if value.respond_to?(:empty?)
+            hsh[attribute.key] = value unless value.empty?
+          else
+            hsh[attribute.key] = value unless value.nil?
+          end
+        end
+      end
+    end
+
+    def to_json(options = {})
+      Yajl::Encoder.encode(to_hash, options.reverse_merge(:pretty => true))
+    end
+  end
+end

data/lib/attr_helper.rb

@@ -0,0 +1,105 @@
+require 'attr_helper/base_attr'
+require 'attr_helper/required_attr'
+require 'attr_helper/serialization'
+
+module AttrHelper
+  def self.included(klass)
+    klass.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+    def inherited(klass)
+      super
+
+      # we might want to undef here so
+      #  that child classes can override
+
+      unless required_attributes.empty?
+        required_attributes.each do |attribute|
+          klass.attr_required attribute.name, {
+            :name => attribute.name,
+            :key => attribute.key,
+            :default => attribute.default,
+            :serialize => attribute.serialize,
+            :if => attribute.if_cond,
+            :unless => attribute.unless_cond
+          }
+        end
+      end
+
+      unless optional_attributes.empty?
+        optional_attributes.each do |attribute|
+          klass.attr_optional attribute.name, {
+            :name => attribute.name,
+            :key => attribute.key,
+            :default => attribute.default,
+            :serialize => attribute.serialize
+          }
+        end
+      end
+    end
+
+    def attr_optional(name, options = {})
+      optional_attributes << BaseAttr.new(name.to_sym, options)
+      attr_accessor name.to_sym
+    end
+
+    def optional_attributes
+      @optional_attributes ||= []
+    end
+
+    def attr_required(name, options = {})
+      required_attributes << RequiredAttr.new(name.to_sym, options)
+      attr_accessor name.to_sym
+    end
+
+    def required_attributes
+      @required_attributes ||= []
+    end
+  end
+
+  def attributes
+    required_attributes + optional_attributes
+  end
+
+  def required_attributes
+    self.class.required_attributes.select do |attribute|
+      attribute.required?(self)
+    end
+  end
+  
+  def optional_attributes
+    self.class.optional_attributes
+  end
+
+  def missing_attributes
+    required_attributes.select do |attribute|
+      value = send(attribute.name)
+      value.respond_to?(:empty?) ? value.empty? : value.nil?
+    end
+  end
+
+  def attr_required?(name)
+    required_attributes.any?{|a| a.name == name}
+  end
+
+  def attr_missing?(name)
+    missing_attributes.any?{|a| a.name == name}
+  end
+
+  def attr_present?(name)
+    !attr_missing?(name)
+  end
+
+  def write_attribute(name, value)
+    self.instance_variable_set("@#{name}", value)
+  end
+
+  def write_attributes(attrs = {})
+    attrs = attrs.symbolize_keys
+    attributes.each do |attribute|
+      value = attrs[attribute.key.to_sym] || attribute.default
+      self.send("#{attribute.name}=", value) unless value.nil?
+    end
+  end
+end

data/lib/data_package/base.rb

@@ -0,0 +1,10 @@
+module DataPackage
+  class Base
+    include AttrHelper
+    include AttrHelper::Serialization
+
+    def initialize(attrs = {})
+      write_attributes(attrs)
+    end
+  end
+end

data/lib/data_package/dialect.rb

@@ -0,0 +1,9 @@
+module DataPackage
+  class Dialect < Base
+    attr_optional :delimiter, :default => ','
+    attr_optional :double_quote, :key => 'doublequote', :default => false
+    attr_optional :line_terminator, :key => 'lineterminator', :default => "\n"
+    attr_optional :quote_char, :key => 'quotechar', :default => "\""
+    attr_optional :skip_initial_space, :key => 'skipinitialspace', :default => false
+  end
+end

data/lib/data_package/field.rb

@@ -0,0 +1,20 @@
+module DataPackage
+  class Field < Base
+    Types = Set.new([
+      :any, :string, :number, :integer,
+      :date, :time, :datetime, :boolean, :binary,
+      :object, :geopoint, :geojson, :array
+    ])
+
+    attr_required :name
+    attr_optional :title
+    attr_optional :description
+    attr_optional :type, :default => :string,
+      :serialize => Proc.new{ |type| type && type.to_s }
+    attr_optional :format
+
+    def type=(value)
+      write_attribute(:type, value.to_sym)
+    end
+  end
+end

data/lib/data_package/license.rb

@@ -0,0 +1,8 @@
+module DataPackage
+  class License < Base
+    attr_optional :id
+    attr_optional :url
+    attr_optional :name
+    attr_optional :version
+  end
+end

data/lib/data_package/package.rb

@@ -0,0 +1,100 @@
+module DataPackage
+  class Package < Base
+    attr_required :name
+
+    attr_optional :path
+    attr_optional :title
+    attr_optional :version
+    attr_optional :description
+    attr_optional :last_modified
+    attr_optional :datapackage_version
+
+    attr_optional :sources, :serialize => Proc.new { |source|
+      source && source.collect(&:to_hash)
+    }
+    
+    attr_optional :licenses, :serialize => Proc.new { |licenses|
+      licenses && licenses.collect(&:to_hash)
+    }
+    
+    attr_optional :maintainers, :serialize => Proc.new { |maintainers|
+      maintainers && maintainers.collect(&:to_hash)
+    }
+
+    attr_optional :contributors, :serialize => Proc.new { |contributors|
+      contributors && contributors.collect(&:to_hash)
+    }
+
+    attr_optional :resources, :serialize => Proc.new { |resources|
+      resources && resources.collect(&:to_hash)
+    }
+
+    attr_accessor :base_path
+
+    def initialize(base_path, attrs = {})
+      @base_path = base_path
+      super(attrs)
+    end
+
+    def save
+      File.open(full_path, 'w+') do |file|
+        file.write(self.to_json)
+      end
+    end
+
+    def sources=(json)
+      @sources = json.collect{|s| Source.new(s)}
+    end
+
+    def licenses=(json)
+      @licenses = json.collect{|l| License.new(l)}
+    end
+
+    def maintainers=(json)
+      @maintainers = json.collect{|m| Person.new(m)}
+    end
+
+    def contributors=(json)
+      @contributors = json.collect{|c| Person.new(c)}
+    end
+
+    def resources=(json)
+      @resources = json.collect{|r| Resource.new(path, r)}
+    end
+
+    private
+
+    def full_path
+      File.join(base_path, 'datapackage.json')
+    end
+
+    class << self
+      def exist?(base_path)
+        File.exist?(full_path(base_path))
+      end
+      
+      def full_path(base_path)
+        File.join(File.expand_path(base_path), 'datapackage.json')
+      end
+
+      def init(base_path, name)
+        pkg = new(base_path, :name => name, :version => '0.0.1')
+        pkg.save
+
+        open(base_path)
+      end
+
+      def open(base_path)
+        full_path = full_path(base_path)
+        base_path = File.expand_path(base_path)
+
+        if File.exist?(full_path)
+          file = File.open(full_path)
+          new(base_path, Yajl::Parser.parse(file))
+        else
+          raise "Couldn't find datapackage.json at #{path}"
+        end
+      end
+    end
+  end
+end

data/lib/data_package/person.rb

@@ -0,0 +1,7 @@
+module DataPackage
+  class Person < Base
+    attr_optional :name
+    attr_optional :email
+    attr_optional :web
+  end
+end

data/lib/data_package/resource.rb

@@ -0,0 +1,75 @@
+require 'data_kit'
+
+module DataPackage
+  class Resource < Base    
+    attr_optional :name
+
+    attr_required :data,
+      :if => Proc.new{ |resource| resource.path.nil? && resource.url.nil?  }
+
+    attr_required :path,
+      :if => Proc.new{ |resource| resource.data.nil? && resource.url.nil?  }
+    
+    attr_required :url,
+      :if => Proc.new{ |resource| resource.data.nil? && resource.path.nil? }
+
+    attr_required :schema, :serialize => Proc.new { |schema| schema.to_hash }
+    attr_optional :dialect, :serialize => Proc.new { |dialect| dialect && dialect.to_hash }
+
+    attr_optional :format, :default => 'csv'
+    attr_optional :media_type, :key => 'mediaType'
+
+    attr_optional :size
+    attr_optional :hash
+    attr_optional :last_modified, :key => 'lastModified'
+
+    attr_accessor :base_path
+
+    def initialize(base_path, attrs = {})
+      @base_path = base_path
+      super(attrs)
+    end
+
+    def schema=(json)
+      @schema = Schema.new(json)
+    end
+
+    def dialect=(json)
+      @dialect = Dialect.new(json)
+    end
+
+    def each_row(&block)
+      case data_source_type
+      when :data
+        data.each(&block)
+      when :path
+        case format
+        when 'csv'
+          DataKit::CSV::Parser.new(full_path).each_row(&block)
+        else
+          raise "Unrecognized resource format #{format} for resource #{name}."
+        end
+      when :url
+        raise "URL based resources are not yet supported"
+      else
+        raise "Resources require one of data, path or url keys to be specified"
+      end
+    end
+
+    private
+
+    def full_path
+      File.join(base_path, path)
+    end
+
+    def data_source_type
+      if data
+        :data
+      elsif path
+        :path
+      elsif url
+        :url
+      end
+    end
+  end
+end

data/lib/data_package/schema.rb

@@ -0,0 +1,13 @@
+module DataPackage
+  class Schema < Base
+    attr_required :fields, :serialize => Proc.new { |fields|
+      fields.collect(&:to_hash)
+    }
+
+    attr_optional :primary_key, :key => 'primaryKey'
+
+    def fields=(json)
+      @fields = json.collect{|f| Field.new(f)}
+    end
+  end
+end

data/lib/data_package/source.rb

@@ -0,0 +1,7 @@
+module DataPackage
+  class Source < Base
+    attr_optional :name
+    attr_optional :email
+    attr_optional :web
+  end
+end

data/lib/data_package/version.rb

@@ -0,0 +1,3 @@
+module DataPackage
+  VERSION = "0.0.1"
+end