wardrobe 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07fb6fbf62eded9e51c5fe99a69a1fcabefad551
+  data.tar.gz: 295843bee2fd360be1843b0bdd80639904f5ede8
+SHA512:
+  metadata.gz: 599f59179ee85174a42e79536a18e845bd4e00f008d664d93e6cea9f8aeb0aec3acce76f68ca90908c955c7c26ba2c2fba2cc41410a55b279b2f27b303e983ae
+  data.tar.gz: 87e8ea4d93b076dff56ed050ff15ea5122b38468015eae10eccec74e0e93a7d5bdca5d2c575973b3341f38dea7946ffce14920887ba82c08b891fa3af4edaed4

data/.codeclimate.yml

@@ -0,0 +1,10 @@
+---
+engines:
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths:
+- test/**/*
+- sandbox/**/*

data/.gitignore

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

data/.ruby-version

@@ -0,0 +1 @@
+2.4.0

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 2.4.0
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+before_install:
+  - gem install bundler
+after_success:
+  - bundle exec codeclimate-test-reporter

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+#Changelog
+
+## v0.1.0
+
+This is the first version of Wardrobe released to RubyGems and considered beta.

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+gem 'multi_json',         '~> 1.12'
+gem 'nokogiri',           '~> 1.7'
+gem 'pry',                '~> 0.10.4'
+gem 'pry-byebug',         '~> 3.4',  platforms: :mri
+gem 'pry-debugger-jruby', '~> 1.1',  platforms: :jruby
+gem 'rubocop',            '~> 0.48', platforms: :mri
+gem 'ruby-prof',          '~> 0.16', platforms: :mri
+gem 'virtus',             '~> 1.0'
+
+group :test do
+  gem 'codeclimate-test-reporter', '~> 1.0.0'
+  gem 'simplecov'
+end

data/Guardfile

@@ -0,0 +1,42 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb$}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb$})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                   { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb$})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb$})
+  # watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb$}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb$})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb$})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2017 Agens AS - https://www.agens.no
+
+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,227 @@
+# Wardrobe
+[![Build Status](https://travis-ci.org/agensdev/wardrobe.svg?branch=master)](https://travis-ci.org/agensdev/wardrobe)
+[![Code Climate](https://codeclimate.com/github/agensdev/wardrobe.svg)](https://codeclimate.com/github/agensdev/wardrobe)
+[![Test Coverage](https://codeclimate.com/github/agensdev/wardrobe/badges/coverage.svg)](https://codeclimate.com/github/agensdev/wardrobe/coverage)
+<!-- [![Gem Version](https://badge.fury.io/agensdev/wardrobe.svg)](https://rubygems.org/gems/wardrobe) -->
+
+Wardrobe is a gem that simplifies creating Ruby objects with attributes. Wardrobe bundles a multitude of plugins. See [list](#bundled-plugins) below.
+
+## Requirements
+
+Wardrobe requires Ruby 2.4.0 or later. Read more about why [here](#ruby-24).
+JRuby should be supported once [9.2.0.0](https://github.com/jruby/jruby/milestone/53) is released
+
+## Installation
+
+```
+gem install wardrobe
+```
+
+## Getting started
+
+```ruby
+require 'wardrobe'
+
+class User
+  include Wardrobe
+  attribute :name, String
+end
+
+User.new(name: 'Wardrobe User')
+```
+
+## Composition
+
+Wardrobe allows you to compose models from multiple modules for easy reuse.
+
+```ruby
+module Name
+  include Wardrobe
+  attribute :first_name, String
+  attribute :last_name, String
+end
+
+class Person
+  include Name
+  attribute :age, Integer
+end
+```
+
+## Coercion
+
+Coercion is enabled by default and works with most types available in Ruby.
+
+Example:
+```ruby
+class User
+  include Wardrobe
+  attribute :id, Integer
+  attribute :name, String
+  attribute :status, Symbol
+  attribute :friends, Array[User]
+  attribute :interests, Hash[String => Symbol]
+end
+
+user = User.new(
+  id: 1.1,
+  name: :'Example User',
+  status: 'active',
+  friends: [
+    {
+      id: '0045',
+      name: 'Another User',
+      status: 'inactive'
+    }
+  ],
+  interests: {
+    'architecture' => 'medium',
+    :sports => 'low',
+    :travel => :high
+  }
+)
+
+# <User:0x007fcc160851f8
+#   @id=1,
+#   @name="Example User",
+#   @status=:active,
+#   @friends=[
+#     <User:0x007fcc16084b68
+#       @id=45,
+#       @name="Another User",
+#       @status=:inactive,
+#       @friends=[],
+#       @interests={}>
+#   ],
+#   @interests={
+#     "architecture"=>:medium,
+#     "sports"=>:low,
+#     "travel"=>:high
+# }>
+```
+
+Coercion also works when mutating `Array`, `Hash` and `Set`. Based on the example above adding a friend to the friends array would coerce the given hash into a `User` object:
+
+```ruby
+user.friends << { id: '22', name: 'Added later' }
+# => [
+#  #<User:0x007fb242c0c960
+#    @id=45,
+#    @name="Another User",
+#    @status=:inactive,
+#    @friends=[],
+#    @interests={}>,
+#  #<User:0x007fb242bd66a8
+#    @id=22,
+#    @name="Added later",
+#    @status=nil,
+#    @friends=[],
+#    @interests={}>
+# ]
+```
+## Block syntax
+
+Many plugins expose options for attributes. These can be enabled on each attribute needed, or you can use a block to enable for a group of attributes.
+
+Per attribute syntax:
+```ruby
+class User
+  include Wardrobe
+  plugin :nil_if_empty
+
+  attribute :first_name, String, nil_if_empty: true
+  attribute :last_name, String, nil_if_empty: true
+  attribute :friends, Array, nil_if_empty: true
+end
+User.new(first_name: '', last_name: '', friends: [])
+# => #<User:0x007fb242b5e798 @friends=nil, @first_name=nil, @last_name=nil>
+```
+
+Block syntax:
+```ruby
+class User
+  include Wardrobe
+  plugin :nil_if_empty
+
+  attributes do
+    nil_if_empty true do
+      attribute :first_name, String
+      attribute :last_name, String
+      attribute :friends, Array
+    end
+  end
+end
+User.new(first_name: '', last_name: '', friends: [])
+# => #<User:0x007fb242b5e798 @friends=nil, @first_name=nil, @last_name=nil>
+```
+
+## Bundled Plugins
+
+Wardrobe comes with numerous plugins and aims at making it easy to write your own.
+
+|Name               |Exposed options      |Development state  |Description       |
+|-------------------|---------------------|-------------------|------------------|
+|validation         |`validates`          |BETA               |dry-validation and Hanami inspired validations for your attributes|
+|immutable          |`immutable`          |BETA               |makes your object immutable. Exposes a #mutate method that will return a new immutable object|
+|dirty_tracker      |`track`              |BETA               |tracks instances and exposes a #_changed? method|
+|default            |`default`            |BETA               |default values for attributes|
+|configurable       |                     |BETA               |allows you to add class level immutable configuration to your classes|
+|nil_if_empty       |`nil_if_empty`       |BETA               |Converts empty objects like `''`, `{}` and `[]` to nil when initializing.|
+|nil_if_zero        |`nil_if_zero`        |BETA               |
+|alias_setters      |`alias_setter(Array)`|BETA               |
+|optional_setter    |`setter`             |BETA               |disable the setter|
+|optional_getter    |`getter`             |BETA               |disable the getter|
+|equality           |`include_in_equality`|BETA               |check if to wardrobe instances are equal|
+|presenter          |                     |POC                |presents your instance as a hash|
+|json_initializer   |                     |POC                |initialize your model with a json string|
+|html_initializer   |                     |POC                |initialize your model with a html string|
+|xml_initializer    |                     |NOT IMPLEMENTED    |initialize your model with a xml string|
+
+## Writing your own plugin
+
+### Example
+
+```ruby
+require 'wardrobe'
+
+Wardrobe.register_setter(
+  name: :capitalize,
+  priority: 25,
+  use_if: ->(atr) { atr.options[:capitalize] && atr.klass == String },
+  setter: lambda do |value, _atr, _instance|
+    value ? value.capitalize : value
+  end
+)
+
+module Capitalize
+  extend Wardrobe::Plugin
+  option :capitalize, Wardrobe::Boolean, setter: :capitalize
+end
+
+Wardrobe.register_plugin(:capitalize, Capitalize)
+
+class Person
+  include Wardrobe
+  plugin :capitalize
+
+  attribute :name, String, capitalize: true
+  attribute :gender, String
+end
+
+Person.new(name: 'foo', gender: 'male')
+#=> #<Person:0x007fba42a273b8 @name="Foo", @gender="male">
+```
+
+## Goals
+
+Wardrobe should:
+
+* be faster than Virtus
+* have no dependencies (plugins may)
+* not pollute the instance level with any methods other than ones prefixed with `_`
+* should be immutable in the config layer allowing subclasses or singleton classes to modify the config
+* be easy to extend with plugins
+* simplify coercions through refinements
+
+## Ruby 2.4
+
+When working on the first "Proof of Concept" for Wardrobe I wanted to use refinements for coercion. This was right before Ruby 2.4 was released that added support for using Kernel#send to call a method defined in a refined class. This was needed to get my first POC working and is why Wardrobe requires ruby 2.4 or above.

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+Rake::TestTask.new(:bench) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_bench.rb'
+end
+
+task :console do
+  sh "irb -I #{File.dirname(__FILE__)}/lib -r wardrobe"
+end
+
+task default: :test

data/examples/new_york_times_article.rb

@@ -0,0 +1,55 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'wardrobe'
+require 'http'
+require 'pry'
+require 'pry-byebug'
+require 'awesome_print'
+
+class Image
+  include Wardrobe
+  plugin :html_initializer
+  plugin :presenter
+  attribute :caption, String, html_selector: proc { |doc| doc.at_css('figcaption span.caption-text')&.text }
+  attribute :credits, String, html_selector: proc { |doc| doc.at_css('figcaption span.credit').xpath('text()')&.text&.strip }
+  attribute :url, String, html_selector: proc { |doc| doc.at_css('div.image img')&.attribute('data-jumbosrc')&.value || doc.attribute('itemid')&.value }
+end
+
+class Article
+  include Wardrobe
+  plugin :html_initializer
+  plugin :presenter
+  attribute :title, String, html_selector: proc { |doc| doc.at_css('header div#story-meta h1#headline')&.text }
+  attribute :headline, String, html_selector: proc { |doc| doc.at_css('header div#story-meta p#story-deck')&.text }
+  attribute :featured_images, Image, html_selector: proc { |doc| doc.at_css('header figure.media') }
+  attribute :published_at, Time, html_selector: proc { |doc| doc.at_css('meta[property="article:published"]').attribute('content')&.value }
+  attribute :modified_at, Time, html_selector: proc { |doc| doc.at_css('meta[property="article:modified"]').attribute('content')&.value }
+  attribute :tags, Array[String], html_selector: proc { |doc| doc.css('meta[property="article:tag"]').map { |t| t.attribute('content')&.value } }
+  attribute :body, Array, html_selector: proc { |doc, _atr, instance|
+    instance.class.parse_body_html(doc.at_css('article#story').children)
+  }
+
+  def self.find(url)
+    res = HTTP.get('https://www.nytimes.com' + url)
+    res = HTTP.cookies(res.cookies).get(res.headers['Location'])
+    res = HTTP.cookies(res.cookies).get(res.headers['Location'])
+    new res.to_s
+  end
+
+  def self.parse_body_html(html)
+    html.css('p.story-body-text, figure.media').map do |item|
+      if item.name == 'p'
+        item.to_html
+      elsif item.name == 'figure'
+        # Support video
+        Image.new(item)
+      end
+    end
+  end
+
+end
+
+url = '/2017/05/07/sports/baseball/wrigley-field-bullpens-renovations.html'
+# url = '/2017/05/03/magazine/a-look-inside-airbuss-epic-assembly-line.html'
+article = Article.find(url)
+ap article._present
+ap Article

data/lib/wardrobe/attribute.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class UnavailableOptionError < StandardError; end
+
+  # Attribute class
+  class Attribute
+    attr_reader :name, :klass, :options, :ivar_name, :setter_name, :store,
+                :setters, :getters
+
+    def initialize(name, klass, defining_object, config, **options)
+      @name = name
+      @ivar_name = "@#{name}"
+      @setter_name = "#{name}="
+      @klass = validate_klass(klass)
+      @options = validate_options(options, config, defining_object)
+      @getters ||= build_getter_array(defining_object)
+      @setters ||= build_setter_array(defining_object)
+      freeze
+    end
+
+    def validate_klass(klass)
+      if klass.is_a?(Array) && klass.count != 1
+        raise StandardError, %(
+          `Array#{klass.map(&:name)}' contains two many classes.
+          No more than one is allowed.
+        )
+      elsif klass.is_a?(Hash)
+        # TODO: Validate hash
+      end
+      klass
+    end
+
+    def merge(other, defining_object, config)
+      merged_options = merge_options(other.options)
+      self.class.new(name, other.klass, defining_object, config, merged_options)
+    end
+
+    private
+
+    def merge_options(other)
+      merged_options = options.dup
+      other.each do |key, value|
+        next if merged_options[key] == value
+        if merged_options[key]
+          raise 'FIX ME! Currently only hash merge is supported' unless value.is_a?(Hash)
+          merged_options[key] = merged_options[key].merge(value)
+        else
+          merged_options[key] = value.dup
+        end
+      end
+      merged_options
+    end
+
+    def build_getter_array(klass)
+      (klass.option_store.values.map do |option|
+        option.getter if option.use_getter_for_atr?(self)
+      end + klass.default_getters).compact.sort
+    end
+
+    def build_setter_array(klass)
+      (klass.option_store.values.map do |option|
+        option.setter if option.use_setter_for_atr?(self)
+      end + klass.default_setters).compact.sort
+    end
+
+    def validate_options(options, config, defining_object)
+      options.each do |name, _|
+        unless config.option_store[name]
+          Wardrobe.logger.error "Option '#{name}' is unavailable for attribute '#{self.name}' on '#{defining_object}'"
+          raise UnavailableOptionError
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/attribute_store.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class AttributeStore < Store
+    def add(name, klass, defining_object, config, **args)
+      mutate do
+        attribute = Attribute.new(name, klass, defining_object, config, **args)
+        if store[name]
+          store[name] = store[name].merge(attribute, defining_object, config)
+        else
+          store[name] = attribute
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/block_setup.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class BlockSetup
+    attr_reader :calling_klass, :block_options
+
+    def initialize(calling_klass)
+      @calling_klass = calling_klass
+      @block_options = {}
+    end
+
+    def run(**kargs, &blk)
+      if (karg = kargs.first)
+        kargs.delete(karg.first)
+        send(*karg) do
+          run(**kargs, &blk)
+        end
+      else
+        instance_exec(&blk)
+      end
+    end
+
+    def attribute(name, klass, **keyargs, &blk)
+      calling_klass.attribute(name, klass, **merged_options_for_attribute(keyargs), &blk)
+    end
+
+    def attributes(**kargs, &blk)
+      run(**kargs, &blk)
+    end
+
+    def merged_options_for_attribute(args)
+      result = args.dup
+      block_options.map do |k, v|
+        option = Wardrobe.options[k]
+        result[k] = send("merge_#{option.klass_name}", result, k, v)
+      end
+      result
+    end
+
+    def merge_boolean(result, key, value)
+      result[key] || value.last
+    end
+
+    def merge_set(result, key, value)
+      convert_to_array_if_not_array(result, key)
+      if result[key]
+        Set.new(value.dup + result[key])
+      else
+        Set.new(value.dup)
+      end
+    end
+
+    def merge_array(result, key, value)
+      convert_to_array_if_not_array(result, key)
+      if result[key]
+        value.dup + result[key]
+      else
+        value.dup
+      end
+    end
+
+    def merge_hash(result, key, value)
+      if result[key]
+        result[key].merge(value)
+      else
+        value.dup
+      end
+    end
+
+    def convert_to_array_if_not_array(result, key)
+      return unless result[key] && !result[key].is_a?(Array)
+      result[key] = [result[key]]
+    end
+
+
+    class << self
+      def register_option(option)
+        return if option.klass == Proc || option.klass == Object
+        send("create_#{option.klass_name}_method", option.name)
+      end
+
+      def create_array_method(name)
+        define_method(name) do |*values, &blk|
+          begin
+            block_options[name] ||= []
+            block_options[name].push(*values)
+            instance_exec(&blk) if blk || block_given?
+          ensure
+            block_options[name].pop(values.length)
+            block_options.delete(name) if block_options[name].empty?
+          end
+        end
+      end
+
+      alias_method :create_set_method, :create_array_method
+
+      def create_hash_method(name)
+        define_method(name) do |**args, &blk|
+          begin
+            block_options[name] ||= {}
+            block_options[name].merge!(args)
+            instance_exec(&blk) if blk || block_given?
+          ensure
+            args.keys.map { |key| block_options[name].delete(key) }
+            block_options.delete(name) if block_options[name].empty?
+          end
+        end
+      end
+
+      def create_boolean_method(name)
+        define_method(name) do |val = true, &blk|
+          begin
+            block_options[name] ||= []
+            block_options[name] << val
+            instance_exec(&blk) if blk || block_given?
+          ensure
+            block_options[name].pop
+            block_options.delete(name) if block_options[name].empty?
+          end
+        end
+      end
+    end
+  end # class BlockSetup
+end # module Wardrobe

data/lib/wardrobe/boolean.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class Boolean
+  end
+end