mona 0.2.3 → 0.4.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -1,3 +1 @@
---format documentation
 --color
---require spec_helper

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem 'rake'
+gem 'httpclient'
+group :development do
+  gem "rspec"
+  gem "bundler"
+  gem "jeweler"
+end

data/LICENSE.txt

@@ -1,21 +1,20 @@
-The MIT License (MIT)
+Copyright (c) 2011 Yamada Masaki
 
-Copyright (c) 2023 Nikita Kononov
+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:
 
-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 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.
+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

@@ -1,193 +1,3 @@
-# Mona
+# Mona [![Build Status](https://travis-ci.org/masarakki/mona.png?branch=update_gems)](https://travis-ci.org/masarakki/mona) [![Dependency Status](https://gemnasium.com/masarakki/mona.png)](https://gemnasium.com/masarakki/mona)
 
-Dependency manager to split and organize Ruby modules and namespaces into highlevel packages and manage relations between them
-Next version of [Rdm gem](https://github.com/droidlabs/rdm)
-
-## Idea
-Main goal to implement the gem was to give developers an ability to keep a large codebase in the single git repository (monorepository) with easy access to:
-1) require only needed dependencies
-2) set up loading policies and inflection rules
-3) manage configuration for different environments
-4) run specific tasks on selected packages
-
-## Example Project File Structure
-```bash
-  ├── Monafile.rb
-  ├── Gemfile
-  ├── Gemfile.lock
-  ├── bounded_contexts
-  │   ├── orders
-  │   │   ├── bin
-  │   │   │   └── run
-  │   │   ├── package
-  │   │   │   ├── orders
-  │   │   │   │   └── export_orders.rb
-  │   │   │   │
-  │   │   │   └── orders.rb
-  │   │   │
-  │   │   └── Package.rb
-  │   │
-  │   ├── orders_db
-  │   │   ├── package
-  │   │   │   └── orders_db.rb
-  │   │   │
-  │   │   └── Package.rb
-  │   │
-  │   └── cart
-  │       ├── package
-  │       │   └── orders.rb
-  │       │
-  │       └── Package.rb
-  │
-  └── configs
-      ├── orders_config
-      │   ├── default.yml
-      │   └── test.yml
-      │
-      └── api_client_config
-          ├── default.yml
-          └── test.yml
-```
-
-## Package
-  The main Mona entity is the "package".
-  Package configuration is defined in Package.rb file.
-  Each package also have an 'entrypoint' file, which can be defined as package namespace module.
-
-  For example for orders package from project structure above entrypoint file could look the following way:
-  ```ruby
-    module Orders
-    end
-
-    require 'some_gem'
-
-    SomeGem.example_initialization_for(__dir__)
-  ```
-
-  You can declare dependencies rules which will determine what packages should be imported before you will initialize current one
-  ```ruby
-    # ./bounded_contexts/orders/Package.rb
-
-    package do
-      name    'marketplace'
-    end
-
-    dependency do
-      import 'orders_db'
-    end
-
-    dependency :test do
-      import 'cart'
-    end
-  ```
-
-  Having that configuration you can call the following code in your bin/run file
-  ```bash
-    #!/usr/bin/env ruby
-    require 'bundler/setup'
-    require 'mona'
-    Mona.init_package
-
-    Orders::ExportOrders.new.call
-  ```
-
-  Let's take a look at ```Mona.init_package``` command. That is the core feature of Mona and it does the following actions
-  1. Detect which package the caller file belongs to
-  You can also provide that file directly using 'from:' parameter
-  ```Mona.init_package(from: __FILE__)```
-  or providing package name
-  ```Mona.init_package('orders')```
-  2. Build dependencies tree: inside each project we have ```dependency do; end``` block which is provide us information which packages should be loaded before the current one
-  3. For each file in dependency tree:
-      * Using Project Code Loader to autoload/preload package classes and modules
-      * Call ```require``` for entrypoint file
-
-## Configs
-  Mona Configs provides interface to declare and access key-value storage can be specified for certain environment
-
-  Instead of using ENV['SOME_VARIABLE_NAME'] in your ruby files you can set up Mona Configs and use env variables in your code like this:
-  ```ruby
-    Mona.configs.api_client.some_variable_name
-  ```
-  Let's define Mona Config for ```api_client```
-  ```yml
-    # ./configs/api_client/default.yml
-    api_client:
-      some_variable_name: ENV['SOME_VARIABLE_NAME']
-
-    # ./configs/api_client/test.yml
-    api_client:
-      some_variable_name: ENV['SOME_VARIABLE_NAME'] + ENV['TEST_ENV_NUMBER']
-  ```
-
-  Rdm looks up for configs in directory have been set in Monafile.rb file with ```set_configs_dir``` method
-  Each config has at least default.yml configuration which can be complemented with :env.yml files
-  Running ```Mona.init_package``` with specified :env will check if corresponding :env.yml file exists and merge it's values to the default configuration
-
-## Project
-  The 2 main entities within Mona project are 'project' and 'package'
-  Project declaration stored in Monafile.rb and a parent directory of the file is considered as the project root
-
-  ### Project Configuration File Example
-
-  ```ruby
-    setup do |project|
-      # set up project.env
-      set_env(ENV['RUBY_ENV'] || raise('RUBY_ENV environment variable is not set'))
-
-      # set up directory to look up for project configs
-      set_configs_dir 'configs'
-
-      # set up directory to look up for packages
-      set_package_dirname 'package'
-      set_packages_lookup_subdir 'bounded_contexts'
-
-      # code loader configuration
-      set_loader :zeitwerk do
-        # file patterns to exclude in ruby autoloading
-        ignore "**/schema_migrations"
-        ignore "**/data_migrations"
-
-        # rules to overwrite default filename-to-class strategy
-        overwrite ->(kname) { kname.gsub(/Foo/) { _1.upcase } }
-        overwrite ->(kname) { kname.gsub('Baz', 'BazBar') }
-
-        # another way to define inflection rules
-        inflect "uuid_generator" => "UUIDGenerator"
-      end
-
-      # definition of the task to run rspec on the specific package
-      register_task :rspec_run, on: :package do |package, args|
-        Dir.chdir(package.root_path) do
-          require 'rspec'
-
-          status = RSpec::Core::Runner.run(args, $stderr, $stdout).to_i
-
-          exit(status)
-        end
-      end
-    end
-  ```
-
-## Tasks
-  Mona tasks are an easy way to declare some procedures can be called on you packages/package
-
-  ### Examples
-  ```ruby
-    # Monafile.rb
-      setup do |project|
-        # ...
-        register_task :puts_package_name, on: :package do |package, args|
-          puts [package.name, args].inspect
-        end
-        # ...
-      end
-  ```
-
-  You can call defined task that way:
-  ```ruby
-    Mona.tasks.puts_package_name(
-      packages: Mona.packages.filter(name: "orders"),
-      args: [1, 2, 3]
-    )
-  ```
+2ch

data/Rakefile

@@ -1,8 +1,49 @@
-# frozen_string_literal: true
+# encoding: utf-8
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
 
-RSpec::Core::RakeTask.new(:spec)
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mona"
+  gem.homepage = "http://github.com/masarakki/mona"
+  gem.license = "MIT"
+  gem.summary = %Q{talk 2ch}
+  gem.description = %Q{talk to 2ch library}
+  gem.email = "masaki@hisme.net"
+  gem.authors = ["masarakki"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
 
-task default: %i[spec]
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mona #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/lib/mona/board.rb

@@ -0,0 +1,50 @@
+require 'kconv'
+
+#
+#Board of 2ch.net
+#
+class Mona::Board
+  attr_reader :host, :board
+
+  #
+  #=== initialize method
+  #
+  #_host_:: subdomain
+  #_board_:: board name
+  #
+  #==== example
+  #if you want to access http://hayabusa2.2ch.net/news4vip/
+  # Mona::Board.new('hayabusa2', 'news4vip')
+  def initialize(host, board)
+    @host = host
+    @board = board
+  end
+
+  #
+  #=== get threads
+  #
+  #array of Thread
+  #
+  def threads
+    @threads ||= connect.toutf8.lines.map do |line|
+      _, id, title, res_num = line.split(/^(\d+)\.dat<>(.+)\((\d+\))$/)
+      Mona::Thread.new(board: self, title: title.strip, res_num: res_num.to_i, id: id.to_i)
+    end
+  end
+
+  private
+
+  #
+  #=== url for subject.txt
+  #
+  def dat_url
+    "http://#{@host}/#{@board}/subject.txt"
+  end
+
+  def connect
+    res = Mona::Client.new.get(dat_url)
+    if res.status == 200
+      res.content.toutf8
+    end
+  end
+end

data/lib/mona/client.rb

@@ -0,0 +1,10 @@
+require 'httpclient'
+class Mona::Client < ::HTTPClient
+  attr_reader :last_accessed_at
+  def initialize(args = {})
+    agent_name = args.delete(:agent_name) || 'Monazilla'
+    agent_name += "/#{Mona.version} (ruby-mona)"
+    super(agent_name: agent_name)
+    self.transparent_gzip_decompression = true
+  end
+end

data/lib/mona/response.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+require 'time'
+
+class Mona::Response
+  attr_accessor :name, :trip, :written_at, :body
+  def initialize(options)
+    options.each do |key, value|
+      self.send("#{key}=", value)
+    end
+  end
+
+  class << self
+    def parse_line(line)
+      name, _, time_str, body, _ = line.to_s.split(/<>/)
+      name, trip = parse_name(name)
+      time = Time.parse(time_str + " +09:00")
+      body = body.strip.split(' <br> ').join("\n")
+      Mona::Response.new(name: name, trip: trip, written_at: time, body: body)
+    end
+
+    def parse_name(name)
+      name, trip = name.split(/ <\/b>/)
+      trip = trip.match(/\w+/)[0] if trip
+      [name, trip]
+    end
+  end
+end

data/lib/mona/thread.rb

@@ -0,0 +1,64 @@
+require 'time'
+
+#
+#Thread of 2ch.net
+#
+#
+#
+class Mona::Thread
+  attr_reader :title, :id, :res_num, :board, :last_accessed_at, :dat_size
+
+  #=== initialize method
+  #
+  #==== required options
+  #_:board_:: instance of Board
+  #_:id_:: thread id
+  #==== optionals
+  #_:title_:: title of thread
+  #_:res_num_:: number of res
+  #_:last_accessed_at_:: timestamp of last accessed time
+  #_:dat_size_:: size of known dat file
+  #
+  def initialize(args = {})
+    @board = args[:board]
+    @title = args[:title]
+    @id = args[:id]
+    @res_num = args[:res_num]
+    @last_accessed_at = Time.at(args[:last_accessed_at] || 0)
+    @dat_size = args[:dat_size] || 0
+  end
+
+  def self.from_url(url)
+    matched = url.match %r{http://(.+)/test/read.cgi/(.+)/(.+)/}
+    raise "Invalid Url" unless matched
+    board = Mona::Board.new(matched[1], matched[2])
+    new(:board => board, :id => matched[3].to_i)
+  end
+
+  def parse_body(body)
+    first = body.lines.first.strip.split(/<>/)
+    @title = first[4] if first[4]
+    body.lines.map{ |line| Mona::Response.parse_line(line) }
+  end
+
+  def reload
+    headers = {'If-Modified-Since' => @last_accessed_at.rfc2822, 'Range' => @dat_size}
+    res = Mona::Client.new.get(dat_url, :header => headers)
+
+    case res.status
+    when 200
+      @dat_size += res.body.bytesize
+      @last_accessed_at = Time.rfc2822(res.header["Last-Modified"].first)
+      body = res.body.toutf8
+      parse_body(body)
+    end
+  end
+
+  private
+  #
+  # === url for thread dat
+  #
+  def dat_url
+    "http://#{board.host}/#{board.board}/dat/#{id}.dat"
+  end
+end

data/lib/mona.rb

@@ -1,110 +1,27 @@
-# frozen_string_literal: true
-
-require 'mona/version'
-require 'dry/system'
-require 'benchmark'
-require "zeitwerk"
-require 'pry'
-
+#Mona - 2ch library.
+#Copyright (C) 2011- masarakki <masaki@hisme.net>
+#
+#== How to access 2ch.net
+#
+#first, create instance of Board.
+#if you want to access to hayabusa2.2ch.net/news4vip,
+# board = Mona::Board.new('hayabusa2', 'news4vip')
+#then you can get list of Thread by
+# threads = board.threads
+#or if you know thread info, you can create Thread instance
+# thread = Mona::Thread.new(:board => Mona::Board.new('hayabusa2', 'news4vip'), :id => 101010101)
+#
 module Mona
-  class Error < StandardError; end
-
-  PROJECT_FILENAME = 'Monafile.rb'
-  PACKAGE_FILENAME = 'Package.rb'
-
-  module Mixins
-    def self.included(base)
-      require 'sorbet-runtime'
-
-      base.extend T::Sig
-    end
-  end
-
-  class Container < Dry::System::Container
-    use :env, inferrer: -> { ENV.fetch("RUBY_ENV", :production).to_sym }
-    # use :logging
-
-    configure do |config|
-      config.root = __dir__
-
-      config.component_dirs.add 'mona' do |dir|
-        dir.namespaces.add nil, key: nil, const: "mona"
-      end
-    end
-  end
-
-  Deps = Container.injector
-
-  Container.finalize! unless Container.env == :test
-
-  Zeitwerk::Loader
-    .for_gem
-    .tap(&:setup)
-    .tap(&:eager_load)
-
-  class << self
-    attr_accessor :current_project
-
-    def init_package(package_name = nil, from: caller_locations.first.path, env: nil, prevent_eager_load: false)
-      sync_current_project!(from) do
-        package_name ||= Container["package.builder"].call(from, current_project.root_path, current_project.package_dirname).name
-        env ||= current_project.env
-
-        Container["package.initializer"].call(package_name, env: env, prevent_eager_load: prevent_eager_load)
-      end
-    end
-
-    def root(from = caller_locations.first.path)
-      sync_current_project!(from) do
-        current_project.root_path
-      end
-    end
-
-    def tasks(from = caller_locations.first.path)
-      sync_current_project!(from) do
-        Container["task.manager"]
-      end
-    end
-
-    def loader(from = caller_locations.first.path)
-      sync_current_project!(from) do
-        current_project.loader
-      end
-    end
-
-    def configs(from = caller_locations.first.path)
-      sync_current_project!(from) do
-        Container["config.manager"]
-      end
-    end
-
-    def packages(from = caller_locations.first.path)
-      sync_current_project!(from) do
-        Container["package.repo"]
-      end
-    end
-
-    def sync_current_project!(path, &block)
-      path = File.expand_path(path)
-      path = File.dirname(path) unless File.directory?(path)
-
-      root = Container['project.find_root'].call(path)
-
-      if @current_project && @current_project.root_path == root
-        return block.call
-      end
-
-      synchronize do
-        @current_project = Container["project.initializer"].call(path)
-
-        block.call
-      end
-    end
+  autoload :Client, 'mona/client'
+  autoload :Board, 'mona/board'
+  autoload :Thread, 'mona/thread'
+  autoload :Response, 'mona/response'
 
-    def synchronize(&block)
-      @mutex ||= Mutex.new
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 1
+  VERSION_PATCH = 0
 
-      @mutex.synchronize(&block)
-    end
+  def self.version
+    [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH].join('.')
   end
 end